System and method of encoding units of data including entity/relationship data, function calls and file data using a common format (CDF) according to formal CDF grammar rules

ABSTRACT

Method and means are described for encoding and decoding stored units of data representing entity/relationship (E/R) data, function calls, and file data by including a prefix with each unit of data which includes a length code, an action code, and a unit identifier code. The data units with prefixes are organized into a data stream by using rules described in a formal grammar. The data stream will typically be transmitted to another program inside the computer or to another computer host or programmable workstation (PWC). When received the data stream is parsed back into data units by reversing the encoding process. After the data units are recovered the appropriate action is taken to process the units. E/R data is entered into or updated in a repository, function calls are passed on to an E/R repository function or other program along with the specified parameters for execution, and file data is stored in standard files. Generated output is captured, encoded into a data stream and transmitted back to requesting PWS which then parses the data stream to recover the output data.

This application is a division of application Ser. No. 08/268,423, filed Jun. 30, 1994, now U.S. Pat. No. 5,437,030, which is a divisional application of application Ser. No. 07/796,117, filed Nov. 20, 1991, which is now U.S. Pat. No. 5,355,493.

FIELD OF THE INVENTION

The present invention relates to systems and methods for encoding, decoding, moving and manipulating computerized data and more particularly data relating to entities and relationships.

BACKGROUND OF THE INVENTION

As used in the field of this invention, entities and relationships are special forms of data that are intended to represent information that is useful in the process of designing and writing computer programs. When this information is stored in a retrievable manner it can be used to aid in the development of computer programs. There are various commercial software systems available which are specially designed to manipulate entity/relationship (E/R) data. One of these systems is IBM's Repository Manager (RM). RM is a predominantly host computer based program. Users of RM may enter their data manually using dialog panels or custom programs may be developed to create, update and retrieve the data. RM provides a set of callable functions which can be accessed by other programs. New RM functions can be created by users as well. These callable functions typically require one or more parameters to perform correctly. It is standard practice in the industry for users to have a personal computer or programmable workstation (PWS) which is used to interface with host computer based programs. When the PWS is sharing the workload with the host, the system is said to be "cooperative". Many kinds of data, not only E/R data, are stored in files. These files may be located on either the host or the PWS.

There is a need for efficient ways to encode E/R data, function calls, and file data in a format which can be transmitted between a PWS and another computer.

Packaging data in a data format of self-describing units is known in the art. The use of grammars as a way of precisely defining syntax is also well known. An efficient comprehensive grammar for self-describing data stream of E/R related data which meets the described need is not found in the prior art.

SUMMARY OF THE INVENTION

The invention provides method and means for encoding and decoding stored units of data representing entity/relationship data, function calls, and file data by including a prefix with each unit of data which includes a length code, an action code, and a unit identifier code. The data units with prefixes are built into a data stream by using rules described in a formal grammar. The data stream can be stored in temporary or permanent storage in the computer. It may be transmitted to another program on the same computer or to another computer--host or PWS. When received the data stream is parsed back into data units by reversing the encoding process. After the data units are recovered the appropriate action may be taken to process the units. E/R data may be entered into or updated in a repository, function calls may be passed on to the appropriate functions along with the specified parameters for execution, and file data may be stored. Generated output data is captured, encoded and returned to the requesting system as a data stream which must be parsed.

DESCRIPTION OF THE DRAWINGS

FIG. 1 shows the block structure of a PWS and host using the invention.

FIG. 2 shows the overview of the steps involved in executing a function call using the invention.

FIG. 3 shows an overview of the build process of the invention.

FIG. 4 shows a representation of a Template Tree Instance used as an example.

DETAILED DESCRIPTION OF THE INVENTION

The invention is embodied in a larger system which will be called the Entity/Relationship Data Movement and Manipulation tool (EDMM) which is designed for use with IBM's Repository Manager/MVS. The invention is, however, independent of the particular host tool used as the repository for the E/R data. EDMM has five components. The first four components described are run-time facilities; the fifth, PF, is used during development, Each of these components is described in detail in later sections. They are:

1. Common Data Format (CDF): EDMM's common data interchange format, which is a means of consistently representing E/R, file record data and function call information within a data stream.

2. Builder: The function that creates a CDF data stream from E/R, file record and function call data.

3. Parser: The function that interprets and decodes information in a CDF data stream.

4. Communication Facility (CF): The function which provides data transfer and remote function routing between work station and host platforms.

5. Productivity Facility (PF): The facility for creating Repository Manager data handling functions based on the work station tool's view of the E/R data.

The overall structure of a host connected PWS system using the invention is shown in FIG. 1. The invention can be used in any system requiring transmission or storage of E/R related data. Thus, a PWS to PWS or host to host connection will work, as will any combination of networked computers. The operation of the system is controlled by a user supplied Application Program 26 which supplies the data and commands for the components of EDMM. The components of the invention are an EDMM Builder, Parser, and Communication Facility. The PWS Builder 11 is required to encode the raw units of data into a formatted data stream. The PWS Parser 15 decodes a formatted data stream. The PWS Communication Facility (CF) 13 provides the high level interface to a standard computer-to-computer communication means 17. Most Builder 12, Host Parser 16, and Host Communication Function 14 provide similar function on the host side, but the internals may be different because the host computer may have an instruction set or operating system that is different than that of the PWS. The Host Communication Function also includes a Router 22, which provides means to detect the presence of and appropriately route the E/R data, function calls, and file data in the data stream. The Function means 20 may be a part of EDMM, may be supplied as a part of a system such as the Repository Manager and/or may include functions supplied by the operating system. E/R data from the PWS is routed to Load means 19. The Unload means 21 is used to retrieve E/R data from the repository and return it to the PWS. The E/R data is stored in the repository means 18 such as is provided through IBM's Repository Manager/MVS. File data is stored in whatever standard way is provided by the operating system such as an MVS partitioned data set (PDS) 23. The Load, Unload, and other Functions may generate output which is captured and routed back to the PWS through the link.

A CDF data stream consists of units of binary and character data. Each unit contains a self-describing prefix area followed by a variable-length data area that might contain other nested units. The prefix area containers a 4-byte length field, a 1-byte action field, and a 1-byte unit identifier field. The data area may or may not contain data depending upon the type of unit being described.

The CDF data stream is supported by two functions, the Parser and the Builder, which exist on both the work station and the host. These functions provide users with an external view of a CDF data stream by dealing with the complexities of the CDF as well as ensuring the syntactical correctness of the data stream. Any function that deals with a CDF data stream must go through the Builder and Parser. The purpose of the Builder is to build a CDF data stream one unit at a time. The purpose of the Parser function is to retrieve data one unit at a time from a CDF data stream. It allows the user to interpret data in the CDF.

The Communication Facility is the component of the EDMM Tool that allows the communication of remote function calls and other information between work station tools and host-based Repository Manager functions. This component relies on RM/PWS, which is supplied with the Repository Manager, to communicate between the host and the work station. A tool on the work station invokes the CF function on the workstation, passing it a CDF data stream containing function call information and any other data necessary to invoke that function. The Host CF interprets the CDF data stream and routes the function calls to the appropriate host Repository Manager function. After the Repository Manager function(s) have executed, the output parameters and processing results are returned to the work station tool in another CDF data stream.

The Productivity Facility (PF) is the component that enables the rapid creation of data manipulation functions based on a variety of views of E/R data in the repository. The PF creates Repository Manager data handling C-Language functions, as described below, for any configuration of entities and relationships defined by the user.

Unload:

A function that retrieves a group of connected entities and relationships from the repository and translates the entity, attribute, and relationship information via the Builder function into a CDF data stream.

Load:

A function that interprets a CDF data stream containing entity, attribute, and relationship information, updating the repository as specified by the action field of each CDF unit.

Delete:

A function that deletes a group of connected entity and relationship instances from the repository.

Copy:

A function that copies a group of connected entity and relationship instances in the repository.

To create an Repository Manager function using PF, the tool builder must first fully define the function to Repository Manager, and generate the Repository Manager function report. The generated Repository Manager report is input to the Productivity Facility, which produces the desired Repository Manager C-Language function based on the tool builder's view of the E/R data. A fully defined Repository Manager function includes the definition of templates and connections.

EDMM RUN-TIME SCENARIO

FIG. 2 will be used to illustrate the overall process of how a work station application and the host interact when the arbitrary function, which will be called FUNCTION₋₋ X, on the host is called from the work station. This scenario can easily be generalized for any activity requested by the application on the workstation.

The scenario is as follows:

1. The application on the workstation uses the Builder function to build a CDF data stream, specifying the FUNCTION₋₋ X function to be invoked on the host along with FUNCTION₋₋ X's input parameter values 31. The data stream may be stored temporarily (in RAM) or more permanently on disk or tape.

2. The application on the work station transmits the data stream to the host by invoking CF on the work station using a regular C function call, passing a pointer to the CDF data stream as input 32. If the host uses a character set which is different from the PWS, then a character set translation is performed by the PWS CF before the data is transmitted.

3. The CF function on the workstation transfer the CDF data to the CF counterpart on the host.

4. After parsing the data stream, 33, the routing is performed 34 based on the FUNCTION₋₋ X function call information in the CDF data stream, the CF router function on the host sets up the appropriate FUNCTION₋₋ X parameter template with input parameter values from the data stream and invokes the FUNCTION₋₋ X host Repository Manager function.

5. The FUNCTION₋₋ X function processes.

6. Upon completion, the FUNCTION₋₋ X function sets the output parameter values and returns to the host CF function with its output parameters in the FUNCTION₋₋ X Repository Manager parameter template 35. Some functions might only generate a return code, but the return code will be processed through the builder the same as other types of data.

7. The CF function on the host takes output parameters from FUNCTION₋₋ X's parameter template and, using the Builder function 36, plates them back into the CDF data stream to be returned to the CF function on the workstation.

8. The CF function on the host returns the CDF data stream to its counterpart CF function on the work station. If character set translation is required, it is performed by the CF after the data is transmitted back to the PWS. The CF function on the work station returns The CDF data to the application 37.

9. The application uses the Parser function 38 to obtain results of the host function call from the CDF data stream, displaying the results to the user where necessary via dialogs, pop-up windows, etc.

Function calls can include E/R data or file data as input or out parameters. The process of handling E/R data coming from the PWS is also similar, but in this case the routing will invoke the Load means which places the E/R data into the repository. Requesting the Unload function results in outputting E/R data that is encoded and sent back to the PWS.

In FIG. 3 an overview of the build process is shown. When the first unit is processed 41 the initialization of memory, etc. is performed 42. If the last unit has been processed 43, then the data stream is constructed from the unit data which has been previously stored in tree form in memory 44. Since the requests from the application program must be a correct sequence, the sequence must be validated 45. The builder and parser are both driven using finite state automata techniques. The state table will be described in detail in Table 1 later. Since only certain state transitions are valid, these are also checked 46. The data for the unit is then stored in a tree in memory for later use in building the final data stream 47.

The parsing process is the reverse of the build process. The application program passes the parser a pointer to a data stream in memory or gives a file name which contains the data stream. The parser returns one unit at a time back to the application program. The parser keeps its own internal pointer into the data stream. The state table of Table 1 describes the details of the state transitions.

FIG. 4 shows a representation of a Template Tree Instance which will be used as an example The data stream built from this Instance is 222 bytes long. The hexadecimal representation of this data stream is as follows:

    __________________________________________________________________________     000000DE                                                                             00020000                                                                             002F0403                                                                             D7C5D9E2                                                                             D6D54040                                                                             0000000C                                                                             0005F1F2                                                                             F4F4F5F6                             00000015                                                                             0406D5C1                                                                             D4C54040                                                                             4040D4C9                                                                             C3C8C1C5                                                                             D3000000                                                                             150403D4                                                                             D6C4E4D3                             C5404000                                                                             00000700                                                                             05C10000                                                                             003F0407                                                                             F0F0F0F0                                                                             F0F0F0F0                                                                             F0F10000                                                                             001A0009                             D7C5D9E2                                                                             D6D54040                                                                             0000000C                                                                             0005F1F2                                                                             F4F4F5F6                                                                             00000015                                                                             0009D4D6                                                                             C4E4D3C5                             40400000                                                                             00070005                                                                             C1000000                                                                             180403C9                                                                             D5E36DD7                                                                             D9D6C300                                                                             00000A00                                                                             05D7E4E2                             C8000000                                                                             3D0407F0                                                                             F0F0F0F0                                                                             F0F0F0F0                                                                             F2000000                                                                             150009D4                                                                             D6C4E4D3                                                                             C5404000                             00000700                                                                             05C10000                                                                             00180009                                                                             C9D5E36D                                                                             D7D0D6C3                                                                             0000000A                                                                             0005D7E4                                                                             E2C80000                             00000000                                                                             00000000                                                                             00000000                                                                             00000000                                                                             00000000                                                                             00000000                                         __________________________________________________________________________

In the following the hexadecimal/character representation of a CDF Data Stream is broken down unit. The prefix is the first 6 bytes. The length is the first 4 bytes of the prefix, the action is the next byte of the prefix, and the id is the last byte of the prefix. The rest of the line is the data (this is of varying length).

    __________________________________________________________________________     000000DE 0002                                                                  Length = 222, action = 0(NONE), id = 2(E/R.sub.-- DATA.sub.-- GROUP.sub.--      H)). data = none.                                                             0000002F 0403D7C5D9E2 D6D54040                                                 Length = 47, action = 4(READ), id = zz (TMPL.sub.-- ID), data = PERSON         0000000C 0005F1F2 F4F4F5F6                                                     Length = 12, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =       124456                                                                         00000015 0406D5C1 D4C54040 4040D4C9 C3C8C1C5 D3                                Length = 21, action = 4(READ), id = 6(FIELD.sub.-- ID), data = NAME            MICHAEL                                                                        00000015 0403D4D6 C4E4D3C5 4040                                                Length = 21, action = 4(READ), id = 3(TMPL.sub.-- ID), data = MODULE           00000007 0005C1                                                                Length = 7, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =        0000003F 0407F0F0 F0F0F0F0 F0F0F0F1                                            Length = 63, action = 4(READ), id = 7(REL.sub.-- ID). data = 0000000001        0000001A 0009D7C5 D9E2D6D5 4040                                                Length = 26, action = 0(NONE), id = 9(RELENT.sub.-- KEY.sub.-- ID), data       = PERSON                                                                       0000000C 0005F1F2 F4F4F5F6                                                     Length = 12, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =       124456                                                                         00000015 0009D4D6 C4E4D3C5 4040                                                Length = 21, action = 0(NONE), id = 9(RELENT.sub.-- KEY.sub.-- ID). data       = MODULE                                                                       00000007 0005C1                                                                Length = 7, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =        A                                                                              00000018 0403C9D5 E36DD7D9 D6C3                                                Length = 24, action = 4(READ), id = 3(TMPL.sub.-- ID). data = INT PROC         0000000A 0005D7E4 E2C8                                                         Length = 10, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =       PUSH                                                                           0000003D 0407F0F0 F0F0F0F0 F0F0F0F2                                            Length = 61, action = 4(READ), id = 7(REL.sub.-- ID), data = 0000000002        00000015 0009D4D6 C4E4D3C5 4040                                                Length = 21, action = 0(NONE), id = 9(RELENT.sub.-- KEY.sub.-- ID). data       = MODULE                                                                       00000007 0005C1                                                                Length = 7, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =        A                                                                              00000018 0009C9D5 E36DD7D9 D6C3                                                Length = 24, action = 0(NONE), id = 9(RELENT.sub.-- KEY.sub.-- ID). data       = INT.sub.-- PROC                                                              0000000A 0005D7E4 E2C8                                                         Length = 10, action = 0(NONE), id = 5(TMPL.sub.-- KEY.sub.-- ID). data =       PUSH                                                                           __________________________________________________________________________

The printable Parser output for this data stream is:

    ______________________________________                                         E/R.sub.-- DATA.sub.-- GROUP.sub.-- ID                                                          NONE                                                          TMPL.sub.-- ID   READ     PERSON                                               TMPL.sub.-- KEY.sub.-- ID                                                                       NONE     124456                                               FIELD.sub.-- ID  READ     NAME MICHAEL                                         TMPL.sub.-- ID   READ     MODULE                                               TMPL.sub.-- KEY.sub.-- ID                                                                       NONE     A                                                    REL.sub.-- ID    READ     0000000001                                           RELENT.sub.-- KEY.sub.-- ID                                                                     NONE     PERSON                                               TMPL.sub.-- KEY.sub.-- ID                                                                       NONE     124456                                               RELENT.sub.-- KEY.sub.-- ID                                                                     NONE     MODULE                                               TMPL.sub.-- KEY.sub.-- ID                                                                       NONE     A                                                    TMPL.sub.-- ID   READ     INT.sub.-- PROC                                      TMPL.sub.-- KEY.sub.-- ID                                                                       NONE     PUSH                                                 REL.sub.-- ID    READ     0000000002                                           RELENT.sub.-- KEY.sub.-- ID                                                                     NONE     MODULE                                               TMPL.sub.-- KEY.sub.-- ID                                                                       NONE     A                                                    RELENT.sub.-- KEY.sub.-- ID                                                                     NONE     INT.sub.-- PROC                                      TMPL.sub.-- KEY.sub.-- ID                                                                       NONE     PUSH                                                 ______________________________________                                    

COMMON DATA FORMAT

The Common Data Format (CDF) provides a consistent means of communicating data among host and workstation functions. It supports communication of E/R instance data and file data. In addition, it allows work station users to indirectly invoke host functions and receive results of host function processing. The CDF will be formally described.

CDF BASIC FORMAT

The CDF consists of units of data used to represent entity, attribute, and relationship instance data, function call information including parameters, and file data. Each CDF unit has a self-describing prefix area followed by a variable-length data area. The prefix area contains a 4-byte length field, a 1-byte action field, and a 1-byte unit identifier field. The data area may or may not contain data depending upon the type of unit being described.

The CDF data stream grammar is described below. Functions that deal with data in the CDF should not maintain or otherwise handle the CDF data stream directly: this information is maintained by the Builder and Parser functions. Note also that CDF data streams consist of binary and character data. The prefix area is represented in binary and the data area in character.

CDF FORMAL GRAMMAR

This section contains a formal description of the CDF grammar. If shows the units that can make up a CDF data stream as well as the semantics that go along with those units. All CDF data streams must conform to this formal grammar in order to be processed by the Builder and Parser functions.

Standard Backus Naur Form (BNF) notation is used to document this description.

    __________________________________________________________________________     Non-terminals                                                                  <cdf.sub.-- data.sub.-- stream>                                                            ::= <edmm.sub.-- data.sub.-- stream> | <er.sub.--                     data.sub.-- group> | <file.sub.-- data.sub.--                         group>                                                             <edmm.sub.-- data.sub.-- stream>                                                           ::= length <no.sub.-- action> edmm.sub.-- data.sub.--                          stream.sub.-- id <edmm .sub.-- data.sub.-- list>                   <edmm.sub.-- data.sub.-- list>                                                             ::= <edmm.sub.-- data> <edmm.sub.-- data.sub.-- list>                          | <edmm.sub.-- data>                                      <edmm.sub.-- data>                                                                         ::= <function.sub.-- call> | <function.sub.-- call>                   <er.sub.-- data.sub.-- group> |                                       <function.sub.-- call> <file.sub.-- data.sub.-- group>             <function.sub.-- call>                                                                     ::= length <no.sub.-- action> fun.sub.-- call.sub.-- id                        fun.sub.-- name <fun.sub.-- parm.sub.-- list>                      <fun.sub.-- parm.sub.-- list>                                                              ::= <fun.sub.-- parm> <fun.sub.-- parm.sub.-- list> |                  <HULL>                                                            <fun.sub.-- parm>                                                                          ::= length <no.sub.-- action> fun.sub.-- parm.sub.-- id                        fun.sub.-- parm.sub.-- name                                                    fun.sub.-- parm.sub.-- value                                       <er.sub.-- data.sub.-- group>                                                              ::= length <no.sub.-- action> er.sub.-- data.sub.-- group.sub.                 -- id <er.sub.-- data.sub.-- list>                                 <er.sub.-- data.sub.-- list>                                                               ::= <er.sub.-- data> <er.sub.-- data.sub.-- list> |                   <er.sub.-- data>                                                   <er.sub.-- data>                                                                           ::= <template> | <rel>                                    <template>  ::= length <crud.sub.-- action> tmpl.sub.-- id                                 template.sub.-- name                                                           <tmpl.sub.-- key.sub.-- list> <field.sub.-- list>                  <tmpl.sub.-- key.sub.-- list>                                                              ::= <tmpl.sub.-- key> <tmpl.sub.-- key.sub.-- list> |                  <tmpl.sub.-- key>                                                 <tmpl.sub.-- key>                                                                          ::= length <no.sub.-- action> temp.sub.-- tmpl.sub.--                          key.sub.-- id <temp.sub.-- key> |                                     length <no.sub.-- action> tmpl.sub.-- key.sub.-- id                            key.sub.-- value                                                   <field.sub.-- list>                                                                        ::= <field> <field.sub.-- list> | <NULL>                  <field>     ::= length <crud.sub.-- action> field.sub.-- id field.sub.--                   name field.sub.-- value                                            <rel>       ::= length <crd.sub.-- action> rel.sub.-- id <rel.sub.-- key>                  <source.sub.-- key>                                                            <target.sub.-- key> |                                                 length <cu.sub.-- action> orel.sub.-- id <rel.sub.-- key>                      <rel.sub.-- posn>                                                              <source.sub.-- key> <target.sub.-- key>                            <source.sub.-- key>                                                                        ::= <relent.sub.-- key> | <relrel.sub.-- key>             <target.sub.-- key>                                                                        ::= relent.sub.-- key> | <relrel.sub.-- key>              <relent.sub.-- key>                                                                        ::= length <no.sub.-- action> relent.sub.-- key.sub.-- id                      template.sub.-- name                                                           <tmpl.sub.-- key.sub.-- list>                                      <relrel.sub.-- key>                                                                        ::= length <no.sub.-- action> relrel.sub.-- key.sub.-- id                      rel.sub.-- key                                                     <file.sub.-- data.sub.-- group>                                                            ::= length <no.sub.-- action> file.sub.-- data.sub.--                          group.sub.-- id <file.sub.-- data.sub.-- list>                     <file.sub.-- data.sub.-- list>                                                             ::= <line> <file.sub.-- data.sub.-- list> | <line>        <line>      ::= length <no.sub.-- action> line.sub.-- id line.sub.--                       value                                                              <crud.sub.-- action>                                                                       ::= create | read | update |                        delete                                                             <cu.sub.-- action>                                                                         ::= create | update                                       <crd.sub.-- action>                                                                        ::= create | read | delete                       <c.sub.-- action>                                                                          ::= create                                                         <no.sub.-- action>                                                                         ::= none                                                           <temp.sub.-- key>                                                                          ::= unique.sub.-- key                                              <rel.sub.-- key>                                                                           ::= unique.sub.-- key                                              <rel.sub.-- posn>                                                                          ::= unique.sub.-- key | 0                                 <NULL>      ::=                                                                Terminals                                                                      length      ::= Binary(4) - Length of unit (including the prefix (                         length(4), action(1), and unit id (1)) plus data)                  none        ::= Binary(1) 00                                                   create      ::= Binary(1) 01                                                   delete      ::= Binary(1) 02                                                   update      ::= Binary(1) 03                                                   read        ::= Binary(1) 04                                                   edmm.sub.-- data.sub.-- stream.sub.-- id                                                   ::= Binary(1) 00                                                   fun.sub.-- call.sub.-- id                                                                  ::= Binary(1) 01                                                   e/r.sub.-- data.sub.-- group.sub.-- id                                                     ::= Binary(1) 02                                                   tmpl.sub.-- id                                                                             ::= Binary(1) 03                                                   temp.sub.-- tmpl.sub.-- key.sub.-- id                                                      ::= Binary(1) 04                                                   tmpl.sub.-- key.sub.-- id                                                                  ::= Binary(1) 05                                                   field.sub.-- id                                                                            ::= Binary(1) 06                                                   rel.sub.-- id                                                                              ::= Binary(1) 07                                                   orel.sub.-- id                                                                             ::= Binary(1) 08                                                   relent.sub.-- key.sub.-- id                                                                ::= Binary(1) 09                                                   relrel.sub.-- key.sub.-- id                                                                ::= Binary(1) 10                                                   fun.sub.-- parm.sub.-- id                                                                  ::= Binary(1) 11                                                   file.sub.-- data.sub.-- group.sub.-- id                                                    ::= Binary(1) 13                                                   line.sub.-- id                                                                             ::= Binary(1) 14                                                   template.sub.-- name                                                                       ::= Char(8) - Name of entity template                              unique.sub.-- key                                                                          ::= Char(10) - A temporary unique identifier for an entity                     whose key has not yet been generated by the repository, or                     a relationship instance. Allowable characters are 0-9,                         the associated integer value must be greater than zero.            key.sub.-- value                                                                           ::= Char(*) - Value of the key                                     field.sub.-- name                                                                          ::= Char(8) - Name of a template field                             field.sub.-- value                                                                         ::= Char(*) - Value of the field                                   fun.sub.-- name                                                                            ::= Char(8) - Name of the function being invoked                   fun.sub.-- parm.sub.-- name                                                                ::= Char(8) - Name of a function parameter                         fun.sub.-- parm.sub.-- value                                                               ::= Char(*) - Value of a function parameter                        line.sub.-- value                                                                          ::= Char(*) - Value of a line in a flat file                       __________________________________________________________________________

BUILDER

The purpose of the Builder function is to build the CDF data stream one unit at a time. The units are built as specified by the FUNCTION₋₋ ID passed in. This function ensures that the CDF data stream being built is valid: if the unit built is invalid, an appropriate return code is passed back to the caller.

The following is the interface to the builder.

    ______________________________________                                         int egppb100(                                                                  unsigned short function.sub.-- id,                                                            IN:      Function to perform                                    short id,      IN:      Unit's id                                              short action,  IN:      Unit's action                                          UNIDATA *data, IN:      Unit's name, key, value                                char *filename,                                                                               IN:      File Name                                              char **memptr, INOUT:   Ptr to block of memory                                 B.sub.-- HNDL *handle,                                                                        INOUT:   Ptr to private data area                               char *cc)      OUT:     Reason code                                            ______________________________________                                    

Note: Data type UNITDATA and B₋₋ HNDL are defined in the EGPBACDF H file. You must include this H file in your function that calls the BUILDER.

The purpose of this function is to build a CDF data stream one unit at a time. A unit is defined as an id, action, and data. A unit may be nested to contain other units. To build a nested structure, add the parent unit first, and then all of its dependents. The Builder has functions that work together to build a Common Data Format Data Stream, as well as functions that write the structure to memory or a file. The functions are as follows:

    __________________________________________________________________________     FIRST      Adds the first unit to the CDF Data Stream. This function is                   only issued once                                                               during the Building of a CDF data stream. The unit that                        accompanies the                                                                FIRST Build action only has an ID (i.e., there is no action                    and no associated                                                              data). Following is a list of the allowable units with which                   the FIRST function                                                             may be associated:                                                             EDMM Data Stream Adds an EDMM Data Stream unit to the Common                   Data                                                                                      Format Data Stream                                                             id   EDMM.sub.-- DATA.sub.-- STREAM.sub.-- ID                                  action                                                                              NONE                                                                      data NULL (ignored)                                                            filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              ER Data Group                                                                             Adds an ER.sub.-- Data Group unit to the Common                                Data Format                                                                    Data Stream                                                                    id   ER.sub.-- DATA.sub.-- GROUP.sub.-- ID                                     action                                                                              NONE                                                                      data NULL (ignored)                                                            filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              File Data Group                                                                           Adds a File Data Group unit to the Common Data                                 Format                                                                         Data Stream                                                                    id   file.sub.-- data.sub.-- group                                             action                                                                              NONE                                                                      data NULL (ignored)                                                            filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                   NEXT       Adds an additional unit. This unit contains an id, action, and                 data portion. If                                                               the Unit is a nesting unit, there may or may not be a data                     portion. Following is                                                          a list of the allowable units with which the Build's NEXT                      function may be                                                                associated:                                                                    Function Call                                                                             Adds a function call unit to the Common Data Format                            Data                                                                           Stream                                                                         id   FUN.sub.-- CALL.sub.-- ID                                                 action                                                                              NONE                                                                      data                                                                                  name = fun.sub.-- name                                                         value = NULL (ignored)                                                         temp.sub.-- key = NULL (ignored)                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              Function Parm                                                                             Adds a function parameter unit to the Common Data                              Format Data Stream                                                             id   FUN.sub.-- PARM.sub.-- ID                                                 action                                                                              NONE                                                                      data                                                                                  name = fun.sub.-- parm.sub.-- name                                             value = fun.sub.-- parm.sub.-- value                                           temp.sub.-- key = NULL (ignored)                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              ER Data Group                                                                             Adds an ER.sub.-- DATA.sub.-- group unit to the                                Common Data Format                                                             Data Stream                                                                    id   ER.sub.-- DATA.sub.-- GROUP.sub.-- ID                                     action                                                                              NONE                                                                      data NULL (ignored)                                                            filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              Template   Adds a template unit to the Common Data Format                                 Data                                                                           Stream                                                                         id   TMPL.sub.-- ID                                                            action                                                                                CREATE                                                                         READ                                                                           UPDATE                                                                         DELETE                                                                         name = template.sub.-- name                                                    value = NULL (ignored)                                                         temp.sub.-- key = NULL (ignored)                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              Template Key                                                                              Adds a template key unit to the Common Data Format                             Data Stream. There are two allowable variations.                               id   TEMP.sub.-- TMPL.sub.-- KEY.sub.-- ID                                     action                                                                              NONE                                                                      data                                                                                  name = NULL (ignored)                                                          value = NULL (ignored)                                                         temp.sub.-- key = temp.sub.-- key                                              rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                                         OR                                                                             id   TEMP.sub.-- KEY.sub.-- ID                                                 action                                                                              NONE                                                                      data                                                                                  name = NULL (ignored)                                                          value = key.sub.-- value                                                       temp.sub.-- key = NULL (ignored)                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              Field      Adds a field unit to the Common Data Format Data                               Stream                                                                         id   FIELD.sub.-- ID                                                           action                                                                                CREATE                                                                         READ                                                                           UPDATE                                                                         DELETE                                                                  data                                                                                  name = field.sub.-- name                                                       value = field.sub.-- value                                                     temp.sub.-- key = NULL (ignored)                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            mempir                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              Rel        Adds a relationship unit to the Common Data Format                             Data                                                                           Stream. There are two allowable variations.                                    id   REL.sub.-- ID                                                             action                                                                                CREATE                                                                         READ                                                                           DELETE                                                                  data                                                                                  name = NULL (ignored)                                                          value = NULL (ignored)                                                         temp.sub.-- key = rel.sub.-- key                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                                         OR                                                                             id   OREL.sub.-- H)                                                            action                                                                                CREATE                                                                         UPDATE                                                                  action                                                                                name = NULL (ignored)                                                          value = NULL (ignored)                                                         temp.sub.-- key = rel.sub.-- key                                               rel.sub.-- posn = rel.sub.-- posn                                       filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              relent key Adds a relationship's source target entity instance                            key to the                                                                     Common Data Format Data Stream                                                 id   RELENT.sub.-- KEY.sub.-- ID                                               action                                                                              NONE                                                                      data                                                                                  name = template.sub.-- name                                                    value = NULL (ignored)                                                         temp.sub.-- key = NULL (ignored)                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              relrel key Adds a relationship's source/target relationship                               instance key                                                                   to the Common Data Format Data Stream                                          is   RELREL.sub.-- KEY.sub.-- ID                                               action                                                                              NONE                                                                      data                                                                                  name = NULL (ignored)                                                          value = NULL (ignored)                                                         temp.sub.-- key = rel.sub.-- key                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              file data group                                                                           Adds a file data group unit to the Common Data                                 Format                                                                         Data Stream                                                                    id   FILE.sub.-- DATA.sub.-- GROUP.sub.-- ID                                   action                                                                              NONE                                                                      data NULL (ignored)                                                            filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                              line       Adds a line unit to the Common Data Format Data                                Stream.                                                                        id   LINE.sub.-- ID                                                            action                                                                              NONE                                                                      data                                                                                  name = NULL (ignored)                                                          value = line.sub.-- value                                                      temp.sub.-- key = NULL (ignored)                                               rel.sub.-- posn = NULL (ignored)                                        filename                                                                            NULL (ignored)                                                            memptr                                                                              NULL (ignored)                                                            handle                                                                              Handle to Builder's Control Block                   ADD.sub.-- STREAM                                                                         Adds a complete, self-contained CDF data stream to the current                 data stream.                                                                   The complete self contained data stream must have been built                   using the Builder.                                                             This unit contains the complete unit in a block of memory. The                 block of                                                                       memory has all the lengths, and nested units resolved. No                      semantic checking will                                                         be performed on the units contained within this unit block.                    However, semantic                                                              checks will be performed to see if this unit is inserted in                    the current CDF data                                                           stream in the proper context.                                                    The ADD.sub.-- STREAM action can be used with the following                  units. Note:                                                                   Memptr and filename are mutually exclusive and required. One                   or the other must                                                              have a value, but not both.                                                    er data group                                                                             Adds a complete self-contained ER Data Group unit                              to the                                                                         EDMM Data Stream                                                               id   NO).sub.-- HO (ignored)                                                   action                                                                              NONE                                                                      data NULL (ignored)                                                            filename                                                                            NULL or filename of er.sub.-- data.sub.--                                      group data stream                                                              to be inserted                                                            memptr                                                                              NULL or pointer to er.sub.-- data.sub.-- group                                 data stream to                                                                 be inserted                                                               handle                                                                              Handle to Builder's Control Block                              file data group                                                                           Adds a complete self-contained File Data Group unit                            to the                                                                         EDMM Data Stream.                                                              id   NO.sub.-- ID (ignored)                                                    action                                                                              NONE                                                                      action                                                                              NONE                                                                      data NULL (ignored)                                                            filename                                                                            NULL or filename of file.sub.-- data.sub.--                                    group data stream                                                              to be inserted                                                            memptr                                                                              NULL or pointer to file data.sub.-- group data                                 stream to                                                                      be inserted                                                               handle                                                                              Handle to Builder's Control Block                   ABNORMAL.sub.-- END                                                                       Caller is requesting an abnormal end to the build process                      before the end of                                                              the data stream has been reached. The Builder function dumps                   any CDF data                                                                   already created into a diagnostic file.                                        id         NO.sub.-- ID (ignored)                                              action     NONE (ignored)                                                      data       NULL (ignored)                                                      filename   NULL (ignored)                                                      memptr     Ignored on input. Data Stream.                                      handle     Handle to Builder's Control Block                        WRITE.sub.-- MEM                                                                          Writes the Common Data Format Data Stream to one contiguous                    block of                                                                       memory and returns the address. Memory is allocated by the                     builder. This                                                                  function can only be successfully executed once for each                       Common Data Format                                                             Data Stream. After this call has been made, there are no other                 valid calls to the                                                             Builder that reference the current CDF data stream.                            id      NO.sub.-- ID (ignored)                                                 action  NONE (ignored)                                                         data    NULL (ignored)                                                         filename                                                                               NULL (ignored)                                                         memptr                                                                               Ignored on input. Data Stream.                                           handle                                                                               Handle to Builder's Control Block                             WRITE.sub.-- FILE                                                                         Writes the Common Data Format Data Stream to a file. The                       Builder opens the                                                              file, writes the Common Data Format Data Stream to the file,                   and closes the file.                                                           The file's name is specified by the caller by the filename                     input parameter. This                                                          function can only be successfully executed once for each                       Common Data Format                                                             Data Stream. After this call has been made, there are no other                 valid calls to the                                                             Builder that reference the current CDF data stream.                            id      NO.sub.-- ID (ignored)                                                 action  NONE (ignored)                                                         data    NULL (ignored)                                                         filename                                                                             Name of the file to which the Builder writes the Common                        Data Format                                                                    Data Stream.                                                             memptr                                                                               NULL (ignored)                                                           handle                                                                               Handle to Builder's Control Block                             __________________________________________________________________________

PARSER

The purpose of the Parser function is to retrieve data one unit at a time from a CDF data stream. The data stream is parsed as specified by the FUNCTION₋₋ ID passed in. During parsing, this function ensures that the CDF data stream is valid; if the unit parsed is invalid, an appropriate return code is passed back to the caller.

The invocation of the Parser function is as follows:

    ______________________________________                                                sc = egppp100 (function.sub.-- id,                                                 cdf.sub.-- file,                                                               &cdf.sub.-- mem,                                                               &handle,                                                                       &id,                                                                           &action,                                                                       &data,                                                                         cc);                                                                ______________________________________                                    

Note: The equivalent function, egphp100 c. exists on the best for users of EDMM.

Return codes are passed back in the SC and CC fields.

Given a CDF data stream and a specific function to perform, the parser accomplishes the specified task against the CDF data stream. In some cases, a unit of data is returned to the caller. The callable interface is:

    ______________________________________                                         int egppp100(                                                                  unsigned short                                                                               IN:      Function to perform                                     function.sub.-- id,                                                            char *filename,                                                                              IN:      Name of file with CDF data                              char **memptr,                                                                               INOUT:   Ptr to CDF data in memory                               P.sub.-- HNDL *handle,                                                                       INOUT:   Ptr to persistent data                                  short *id,    OUT:     Parsed unit's id                                        short *action,                                                                               OUT:     Parsed unit's action                                    UNITDATA *data,                                                                              OUT:     Parsed unit's data                                      char *cc)     OUT:     Condition code                                          ______________________________________                                    

The UNITDATA data type is defined in the EGPBACDF Header file. The UNITDATA type further defines the kinds of data that can be returned for a CDF unit; depending upon the type of unit parsed, its data portion will be in certain fields of this structure as specified in the Header file. This Header file must be included in any function that interacts with the CDF data stream in any way.

The purpose of this function is to parse a CDF data stream one unit at a time. A CDF unit is defined as having a length, id, action, and sometimes data. All but the length of the unit is returned to the caller from the Parser function. A unit may be nested to contain other units. When parsing, the caller receives units in the order they occur in the CDF data stream. Thus, the "nesting" unit is parsed before its nested "children" units. The caller has the option to skip these parent nesting units should that unit type not make sense to them.

In addition to simply parsing units from the data stream, the Parser also verifies the semantic correctness of the data stream at each step through parsing. If at any point during the parsing process that unit is invalid with respect to the unit previously parsed, or the unit's action is invalid for the particular unit, the parsing process terminates with an appropriate condition code to alert the caller of an invalid data stream.

When the Parser function reaches the end of the data stream, or when an ABNORMAL₋₋ END function is specified, a warning code accompanied by an EOF condition code is returned to the caller.

The Parser function is intended to provide a complete package of functions that can be executed against the given CDF data stream. The functions and their descriptions are as follows:

    __________________________________________________________________________     FIRST      Parse the first CDF unit from the data stream. This function                   is only issued                                                                 once during the parsing of a CDF data stream. The only units                   the caller                                                                     can expect from a FIRST call appear below. These units are the                 "header"                                                                       units in the data stream. Their actions are always NONE and                    they have no                                                                   data. If any other unit appears first in the data stream, the                  Parser terminates                                                              with an "invalid data stream" condition code. Following is a                   list of the                                                                    input and output data associated with a FIRST call:                            Edmm Data Stream                                                                          The common Data Format Data Stream being parsed                                may contain Function, FR and File data.                                        function.sub.-- id                                                                       FIRST                                                                filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data stream in memory                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        EDMM.sub.-- DATA.sub.-- STREAM.sub.-- ID                             action    None                                                                 data      NULL (fields in structure are empty)                      E/R Data Group       The Common Data Format Data Stream being                                       parsed                                                                         contains E/R data                                                              function.sub.-- id FIRST                                             filename  Name of file containing CDF data stream                                        (opened by Parser)                                                   memptr    Pointer to CDF data stream in memory                                           (updated as stream is parsed)                                        handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        ER.sub.-- DATA.sub.-- GROUP.sub.-- ID                                action    NONE                                                                 data      NULL (fields in structure are empty)                      File Data Group                                                                           The Common Data Format Data Stream being parsed                                contains File data                                                             function.sub.-- id FIRST                                                       filename  Name of file containing CDF data stream                                        (opened by Parser)                                                   memptr    Pointer to CDF data stream in memory                                           (updated as stream is parsed)                                        handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        FILE.sub.-- DATA.sub.-- GROUP.sub.-- ID                              action    NONE                                                                 data      NULL (fields in structure are empty)           NEXT       Parse the next unit from the CDF data stream. This function                    presumes that                                                                  a position has already been established in the stream via the                  FIRST                                                                          function. If positioning has not already been established, the                 Parser returns                                                                 with an error, but the user has the ability to then issue a                    FIRST to correct                                                               the problem. The unit returned contains an id, action, and                     data portion, if                                                               data exists for that unit. Following is a list of the input                    and output data                                                                associated with a Parser NEXT function:                                        Function Call                                                                             The CDF data stream contains a function call data                              function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        FUN.sub.-- CALL.sub.-- ID                                            action    NONE                                                                 data                                                                                       name = fun.sub.-- name                                                         value = NULL (empty)                                                           temp.sub.-- key = NULL (empty)                                                 rel.sub.-- posn = NULL (empty)                          Function Parameter                                                                        Function Call data in data stream contains                                     function                                                                       parameter data                                                                 function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        FUN.sub.-- PARM.sub.-- ID                                            action    NONE                                                                 data                                                                                       name = fun.sub.-- parm.sub.-- name                                             value = fun.sub.-- parm.sub.-- value                                           temp.sub.-- key = NULL (ignored)                                               rel.sub.-- posn = NULL (ignored)                        ER Data Group                                                                             The CDF data stream contains E/R data                                          function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        ER.sub.-- DATA.sub.-- GROUP.sub.-- ID                                action    NONE                                                                 data      NULL (empty)                                              Template   E/R data in data stream contains template instance                             function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        TEMPL.sub.-- ID                                                      action                                                                                     CREATE                                                                         READ                                                                           UPDATE                                                                         DELETE                                                             data                                                                                       name = template.sub.-- name                                                    value = NULL (empty)                                                           temp.sub.-- key = NULL (empty)                                                 rel.sub.-- posn = NULL (empty)                          Template Key                                                                              Template instance in data stream contains template                             key                                                                            (temporary or real)                                                            function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        TEMP.sub.-- TMPL.sub.-- KEY.sub.-- ID                                action    NONE                                                                 data                                                                                       name = NULL (empty)                                                            value = NULL (empty)                                                           temp.sub.-- key = temp.sub.-- key                                              rel.sub.-- posn = NULL (empty)                                     OR                                                                             function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        TMPL.sub.-- KEY.sub.-- ID                                            action    NONE                                                                 data                                                                                       name = NULL (empty)                                                            value = key.sub.-- value                                                       temp.sub.-- key = NULL (empty)                                                 rel.sub.-- posn = NULL (empty)                                     Field     Template instance in data stream contains                                      field                                                                          function.sub.-- id NEXT                                              filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        FILED.sub.-- H)                                                      action                                                                                     CREATE                                                                         READ                                                                           UPDATE                                                                         DELETE                                                             data                                                                                       name = field.sub.-- name                                                       value = field.sub.-- value                                                     temp.sub.-- key = NULL (empty)                                                 rel.sub.-- posn = NULL (empty)                          Rel        E/R data in data stream contains relationship                                  instance                                                                       (two allowable variations)                                                     function.sub.-- id NEXT                                                        filename                                                                            Name of file containing CDF data stream                                   memptr                                                                              Pointer to CDF data in memory (updated                                         from previuos parse)                                                      handle                                                                              Pointer to Parser's persistent data control                                    block                                                                     id   REL.sub.-- H)                                                             action                                                                                     CREATE                                                                         READ                                                                           DELETE                                                             data                                                                                       name = NULL (empty)                                                            value = NULL (empty)                                                           temp.sub.-- key = rel.sub.-- key                                               rel.sub.-- posn = NULL (empty)                                     OR                                                                             function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        OREL.sub.-- ID                                                       action                                                                                     CREATE                                                                         UPDATE                                                             data                                                                                       name = NULL (empty)                                                            value = NULL (empty)                                                           temp.sub.-- key = rel.sub.-- key                                               rel.sub.-- posn = rel.sub.-- posn                       relent key Relationship in data stream has source/target that                             is                                                                             entity instance                                                                function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        RELENT.sub.-- KEY ID                                                 action    NONE                                                                 data                                                                                       name = template.sub.-- name                                                    value = NULL (empty)                                                           temp.sub.-- key = NULL (empty)                                                 rel.sub.-- posn = NULL (empty)                          relrel key Relationship in data stream has source/target that                             is                                                                             relationship instance                                                          function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        RELREL.sub.-- KEY.sub.-- ID                                          action    NONE                                                                 data                                                                                       name = NULL (empty)                                                            value = NULL (empty)                                                           temp.sub.-- key = rel.sub.-- key                                               rel.sub.-- posn = NULL (empty)                          file data group                                                                           The CDF data stream contains file data                                         function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous parse)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        FILE.sub.-- DATA.sub.-- GROUP.sub.-- ID                              action    NONE                                                                 data      NULL (empty)                                              line       File data in data stream contains line data                                    function.sub.-- id NEXT                                                        filename  Name of file containing CDF data stream                              memptr    Pointer to CDF data in memory (updated                                         from previous group)                                                 handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        LINE.sub.-- ID                                                       action    NONE                                                                 data                                                                                       name = NULL (empty)                                                            value = line.sub.-- value                                                      temp.sub.-- key = NULL (empty)                                                 rel.sub.-- posn = NULL (empty)               PREVIOUS   Return unit data for previous unit parsed from CDF data                        stream. This                                                                   function presumes that a position has already been established                 in the stream                                                                  via a FIRST function. If positioning has not already been                      established, the                                                               Parser returns with an error, but the user has the ability to                  then issue a                                                                   FIRST to correct the problem. The unit returned is the unit                    that has JUST                                                                  been parsed; that is, the caller can only go back ONE unit.                    The unit                                                                       returned contains an id, action, and data portion, if data                     exists for that unit.                                                          Any unit may be returned as a result of the Parser PREVIOUS                    function.                                                                      Refer to the lists of units for FIRST or NEXT for the complete                 list.                                                               SKIP       Skips the unit previously parsed from the CDF data stream.                     Again, this                                                                    function presumes that a position has already been established                 in the stream                                                                  via a FIRST function. This function does not return any unit                   data. Rather,                                                                  it simply skips the unit that has JUST been parsed; successive                 SKIP calls to                                                                  the Parser do NOT result in several units being skipped, but                   only succeed in                                                                skipping the same unit over and over. A SKIP call can be used                  to skip an                                                                     entire nested unit of CDF data or a single unit of data                        (although skipping a                                                           single unit is an effective no-op).                                 GET.sub.-- STREAM                                                                         Copy the PREVIOUS unit parsede (including all of its imbedded                  units) into a                                                                  separate file or memory location as specified by the caller.                   This call is                                                                   issued when the caller has parsed an ER.sub.-- DATA.sub.--                     GROUP or                                                                       FILE.sub.-- DATA.sub.-- GROUP unit and wants the entire E/R                    Data Group of File                                                             Data Group data stream imbedded within the CDF stream being                    parsed to                                                                      be placed in a separate location for later access. The                         original data stream is                                                        not changed; the E/R or File data being copied is SKIPped in                   the original                                                                   data stream so that parsing resumes at the unit following that                 imbedded                                                                       stream.                                                                          The GET.sub.-- STREAM function cannot be issued on any units                 other                                                                          than ER.sub.-- DATA.sub.-- GROUP and FILE.sub.-- DATA.sub.--                   GROUP and these units must                                                     have first been parsed by the caller. An attemp to issue                       GET.sub.-- STREAM on                                                           any other unit results in an error and the Parser will                         terminate.                                                                       Possible values sent to and returned from the Parser for                     GET.sub.-- STREAM are:                                                         E/R Data Stream                                                                           The E/R Data Gfroup, complete with imbedded                                    template and relationship data, is copied from the                             CDF                                                                            data stream being parsed.                                                      (IN) function.sub.-- id GET.sub.-- STREAM                                      (IN) filename                                                                            Name of file which is to contain copied                                        E/R Data Group data stream (NULL if data                                       is to be copied to memory)                                           (IN/OUT) memptr                                                                          Ignored upon input. Upon output                                                and if filename is not specified,                                              location in                                                                    memory of E/R Data Group copied                                      handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        ER.sub.-- DATA.sub.-- GROUP.sub.-- ID                                action    NONE                                                                 data      NULL (fields in structure are empty)                                           A subsequent NEXT on the original data                                         stream yields the unit immediately                                             following the entire                                                           E/R Data Group.                                           File Data Group                                                                           The File Data Group, complete with imbedded lines,                             is                                                                             copied from the CDF data stream being parsed.                                  (IN) function.sub.-- id GET.sub.-- STREAM                                      (IN) filename                                                                            Name of file which is to contain copied                                        File Data Group data stream (NULL if                                           data                                                                           is to be copied to memory)                                           (IN/OUT) memptr                                                                          Ignored upon input. Upon output                                                and if filename is not specified,                                              location in                                                                    memory of File Data Group copied                                     handle    Pointer to Parser's persistent data                                            control                                                                        block                                                                id        FILE.sub.-- DATA.sub.-- GROUP.sub.-- ID                              action    NONE                                                                 data      NULL (fields in structure are empty)                                             A subsequent NBXT on the original data                                       stream yields the unit immediately                                             following the entire                                                           E/R Data Group.                                ABNORMAL.sub.-- END                                                                       Alerts Parser function that caller has experienced problem and                 that parsing                                                                   is to be terminated on the CDF data stream currently being                     parsed. When                                                                   this function is specified, the Parser does the necessary work                 to clean up all                                                                temporary and persistent data used during parsing. This                        enables the parsing                                                            process to begin cleanly for the same calling function on a                    new data stream.                                                               (Note: the processing done for this function is exactly the                    same as when the                                                               Parser reaches the end of the CDF data stream.)                     __________________________________________________________________________

FREE CDF FUNCTION

The purpose of the Free CDF function is to discard CDF data stream memory. Free CDF interface:

    ______________________________________                                         (In) CDF.sub.-- MEM          char*                                             Parameters    Descriptions                                                     CDF.sub.-- MEM                                                                               Pointer to CDF data in memory.                                   The invocation of the Free CDF function is as follows:                          char *cdf.sub.-- mem;                                                          short sc;                                                                       . . .                                                                         egppafre (cdf.sub.-- mem);                                                    ______________________________________                                          Note:                                                                          The equivalent function, egphafre e, exists on the host for users of EDMM                                                                               

EDMM COMMUNICATION FACILITY

The purpose of the EDMM Communication Facility is to enable a work station application to invoke a fully-integrated Repository Manager/MVS function on the host communicating all file and E/R data between the work station and host functions. The communication is achieved by an open/close Repository Manager/MVS function that opens the Repository Manager, transfers the function interface, file, and E/R data to the host in a CDF data stream, invokes the host fully-integrated RM host function specified in the data stream, returns the function interface and all data associated with the function call in a CDF data stream to the work station, and closes the Repository Manager/MVS. If no errors are encountered, output parameters and data, if any, for the host function, are returned to the caller in a CDF data stream.

    ______________________________________                                         Interface                                                                      EDMM Communication Facility Interface                                          ______________________________________                                         (In) CDF.sub.-- FILE       char 47                                             (In/Out) CDF.sub.-- MEM    char *                                              (Out) SC                   short                                               (Out) CC                   char 9                                              ______________________________________                                         Parameters Descriptions                                                        ______________________________________                                         CDF.sub.-- FILE                                                                           Name of work station file containing CDF                                       data stream. (Opened and closed in this                                        function.) CDF.sub.-- FILE and                                                 CDF.sub.-- MEM are mutually                                                    exclusive. See the description                                                 of CDF.sub.-- MEM for more information                                         about the CDF data stream content.                                              When the EDMM Communication Facility                                          returns control to the caller, the                                             output CDF data stream will usually                                            be in memory (i.e., pointed to by                                              CDF.sub.-- MEM). However, if sufficient                                        memory is not available, the CDF data                                          stream will be written to a file, and                                          CDF.sub.-- MEM will return a NULL                                              value. As currently implemented, the                                           output CDF file is allocated within this                                       function and the name is hard-coded as                                         EGPPTCDF.OUT.                                                       CDF.sub.-- MEM                                                                            Work station address of CDF data stream                                        in memory. CDF.sub.-- FILE and CDF.sub.-- MEM                                  are mutually exclusive: The caller of this                                     function will use the Builder to create a CDF                                  data stream that contains information on the                                   function to be invoked on the host and its                                     parameters, possibly including an imbedded                                     CDF data stream containing file or E/R data                                    units.                                                                          As an output parameter, CDF.sub.-- MEM points                                 to a CDF data stream that contains output                                      parameters returned by the host function that                                  was invoked on behalf of the caller. Again,                                    depending on the host function interface, the                                  CDF data stream may also include an                                            imbedded CDF data stream containing file or                                    E/R data units.                                                                 The caller will use the Parser to retrieve                                    this information from the CDF data stream.                          SC         Return code representing processing results                         CC         Condition code representing processing results                      ______________________________________                                    

The invention of the EDMM Communication Facility is as follows:

    ______________________________________                                         #include prototype function calls for EDMM, Builder and Parser                 sc = egppt00 (cdf.sub.-- file,                                                 &cdf.sub.-- mem,                                                               cc);                                                                           ______________________________________                                    

Return codes are passed back in the CC and SC fields.

PRODUCTIVITY FACILITY

The Productivity Facility (PF) is the component that

enables the rapid creation of data manipulation facilities based on a variety of views of E/R data in the repository and

customizes the Communication Facility function.

The PF creates Repository Manager C-Language functions described below.

Load BB: A function that interprets a CDF data stream containing entity, attribute, and relationship information. It updates the repository as specified by the action field of each CDF unit.

Unload BB: A function that retrieves a group of connected entities and relationships from the repository and translates the entity, attribute, and relationship information via the Builder function into a CDF data stream.

Copy BB: A function that copies a group of connected entity and relationship instances in the repository.

Delete BB: A function that deletes a group of connected entity and relationship instances from the repository.

Communication Facility: The host portion of CF that enables the function routing to your RM functions.

LOAD BB

The Load₋₋ BB function adds or updates a logical unit of data in the repository as specified by the CDF data stream. Data is passed in a template and relationship units in an ER data group.

Separate functions must be defined for each data view needed by the application (i.e. each different template tree).

Note: Currently this function does not obtain any locks or perform any commits. In situations where the data must be locked before update, a lock must be separately obtained on the necessary entity instance prior to invoking the load function. A Commit should be performed after invoking this function in order to make changes to the repository permanent.

    ______________________________________                                         Interface                                                                      Load.sub.-- BB Interface                                                       ______________________________________                                         (In) CDF.sub.-- MEM   Fixed   32                                               (In) CDF.sub.-- FILE  Char    46                                               (Out) SC              Fixed   16                                               (Out) CC              Char     8                                               ______________________________________                                         Parameters   Descriptions                                                      ______________________________________                                         CDF.sub.-- MEM                                                                              Host memory location of CDF data                                               stream containing E/R data to be added,                                        deleted, or updated in the repository.                                         Caller will use the Builder function to                                        put data to be loaded in a CDF data                                            stream.                                                           CDF.sub.-- FILE                                                                             Host file containing CDF data stream                              SC           Severity code reflecting processing results                       CC           Condition code reflecting processing                                           results                                                           ______________________________________                                          Note: CDF.sub.-- MEM and CDF.sub.-- FILE are mutually exclusive.         

Return codes are passed back in the CS and CC fields of the data stream. Since the Load₋₋ BB functions are generated, each Load₋₋ BB has the same set of possible return codes.

UNLOAD BB

The Unload₋₋ BB function retrieves a logical unit of data from the repository and puts it in CDF data stream. Data is returned as template and relationship units in an ER data group.

Separate functions must be defined for each view needed by the application (i.e. each different template tree).

Note: Currently this function does not obtain any locks. To avoid a "dirty read" a lock must be obtained on the aggregation instance.

    ______________________________________                                         Interface                                                                      Unload.sub.-- BB Interface                                                     ______________________________________                                         (In) SYSKEY           Fixed   31                                               (Out) CDF.sub.-- MEM  Fixed   32                                               (Out) CDF.sub.-- FILE Char    46                                               (Out) SC              Fixed   16                                               (Out) CC              Char     8                                               ______________________________________                                         Parameters  Descriptions                                                       ______________________________________                                         SYSKEY      System-assigned key of the aggregation                                         instance to be unloaded.                                           CDF.sub.-- MEM                                                                             Host memory location of CDF data                                               stream containing the E/R data retrieved                                       from the repository. Caller will use the                                       Parser function to extract the data from                                       the CDF data stream.                                               CDF.sub.-- FILE                                                                            Host file name of CDF data stream                                              containing the E/R data retrieved from                                         the repository. Caller will use the Parser                                     function to extract the data from the                                          CDF data stream.                                                   SC          Severity code reflecting processing results                        CC          Condition code reflecting processing results                       ______________________________________                                          Note: CDF.sub.-- MEM and CDF.sub.-- FILE are mutually exclusive.         

HOST FUNCTION INVOCATION

Return codes are passed back in the CS and CC fields of the data stream. Since the Unload₋₋ BB functions are generated, each Unload₋₋ BB has the same set of possible return codes.

COPY₋₋ BB

The purpose of the Copy₋₋ BB function is to allow the user to copy an entire object in the repository, storing the duplicate under another name. Any data view (i.e. a template tree) can can be copied using this function. The target of the Copy₋₋ BB must not already exist. The Copy₋₋ BB functions do not copy shareable subcomponents, but will create relationships to the shared subcomponents.

Note: As used herein all objects and shareable subcomponents have a root template with the following attributes: name, qualifier, and level. This function and its interface will have to be modified the data view does not conform to this naming standard.

Note: Currently this function does not obtain any locks or perform any commits. To avoid a "dirty read" a lock must be obtained on the source aggregation instance. A Commit should be performed after invoking this function in order to make changes to the repository permanent obtained to avoid a "dirty read".

    ______________________________________                                         Interface                                                                      Copy.sub.-- BB Interface                                                       ______________________________________                                         (In) SYSKEY           Fixed   31                                               (In) TRG.sub.-- NAME  Char    32                                               (In) TRG.sub.-- QLFR  Char     8                                               (In) TRG.sub.-- LVL   Char     2                                               (Out) SC              Fixed   16                                               (Out) CC              Char     8                                               ______________________________________                                         Parameters    Descriptions                                                     ______________________________________                                         SYSKEY        System-assigned key of the aggregation                                         instance to be copied.                                           TRG.sub.-- NAME                                                                              Name of target aggregation instance                              TRG.sub.-- QLFR                                                                              Qualifier of target aggregation instance                         TRG.sub.-- LVL                                                                               Level of target aggregation instance                             SC            Severity code reflecting processing                                            results                                                          CC            Condition code reflecting processing                                           results                                                          ______________________________________                                    

Return codes are passed back in the SC and CC fields of the data stream. Since the Copy₋₋ BB functions are generated, each Copy₋₋ BB has the same set of possible return codes.

DELETE BB

The purpose of the Delete₋₋ BB function is to enable the user to delete an object instance from the repository. This function can delete any data view (i.e. template tree). The Delete₋₋ BB functions defined here do not delete shareable subcomponents, but will delete the relationships to the shared subcomponents. The Load function can be used to delete individual entity instances within an aggregation instance.

Note: Currently this function does not obtain any locks or perform any commits. A DELETE lock must be obtained on the aggregation instance before invoking the function. A Commit should be performed after invoking this function in order to make the delete permanent.

    ______________________________________                                         Interface                                                                      Delete.sub.-- BB Interface                                                     ______________________________________                                         (In) SYSKEY           Fixed   31                                               (Out) SC              Fixed   16                                               (Out) CC              Char     8                                               ______________________________________                                         Parameters  Descriptions                                                       ______________________________________                                         SYSKEY      System-assigned key of the aggregation                                         instance to be deleted.                                            SC          Severity code reflecting processing results                        CC          Condition code reflecting processing results                       ______________________________________                                    

Return codes are passed back in the SC and CC fields of the data stream. Since the Delete₋₋ BB functions are generated, each Delete₋₋ BB has the same set of possible return codes.

BUILDER-PARSER STATE TABLES

Documented below is a state table that describes the valid units and actions when parsing or building a CDF data stream.

                                      TABLE I                                      __________________________________________________________________________     EDMM Builder Parser State Table                                                                        Next                                                   State                                                                             CDF Unit/Builder/Parser Action                                                                      State                                                                             Description                                         __________________________________________________________________________      0 EDMM.sub.-- DATA/STREAM/FIRST                                                                        1 Initial Start State.                                   ER.sub.-- DATA.sub.-- GROUP/FIRST                                                                   24                                                        FILE.sub.-- DATA.sub.-- FROUP/FIRST                                                                 31                                                      1 FUN.sub.-- CALL/NEXT  2 Processing an                                          EDMM.sub.-- DATA.sub.-- STREAM/SKIP                                                                  0 edmm.sub.-- data.sub.-- stream.                      2 FUN.sub.-- CALL/NEXT  2 Processing a function call.                            FUN.sub.-- PARM/NEXT  2                                                        ER.sub.-- DATA.sub.-- GROUP/NEXT                                                                     3                                                        ER.sub.-- DATA.sub.-- GROUP/ADD.sub.-- STREAM                                                       25                                                        FUN.sub.-- CALL/SKIP 26                                                        FILE.sub.-- DATA.sub.-- GROUP/NEXT                                                                  33                                                        FILE.sub.-- DATA.sub.-- GROUP/ADD.sub.-- STREAM                                                     35                                                        FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                      3 TMPL/NEXT             4 Processing an er.sub.-- data.sub.-- group              REL/NEXT              7 that is paired with a                                  OREL/NEXT            36 function.sub.-- call. (Root is an                      ER.sub.-- DATA.sub.-- GROUP/SKIP                                                                     2 edmm.sub.-- data.sub.`3 stream                         ER.sub.-- DATA.sub.-- GROUP/GET.sub.-- STREAM                                                        2                                                      4 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                     5 Processing a template,                                 TMPL.sub.-- KEY/NEXT  5 (Root is an                                            TMPL/SKIP            27 edmm.sub.-- data.sub.-- stream)                      5 FUN.sub.-- CALL/NEXT  2 Processing the a template                              TMPL/NEXT             4 key list of a template. (Root                          TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                     5                                                        TMPL.sub.-- KEY/NEXT  5                                                        FIELD/NEXT            6                                                        REL/NEXT              7                                                        OREL/NEXT            36                                                        FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                      6 FUN.sub.-- CALL/NEXT  2 Processing a field list of a                           TMPL/NEXT             4 template. (Root is an                                  FIELD/NEXT            6 edmm.sub.-- data.sub.-- stream)                        REL/NEXT              7                                                        OREL/NEXT            36                                                        FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                      7 RELREL.sub.-- KEY/NEXT                                                                               8 Processing a rel. (Root is an                          RELENT.sub.-- KEY/NEXT                                                                               9 edmm.sub.-- data.sub.-- stream)                        REL/SKIP             27                                                      8 RELREL.sub.-- KEY/NEXT                                                                              11 Processing a relrel.sub.-- key                         RELENT.sub.-- KEY/NEXT                                                                              12 which is the source key of a                                                   rel. (Root is an                                                               edmm.sub.-- data.sub.-- stream)                      9 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    10 Processing a relent.sub.-- key                         TMPL.sub.-- KEY/NEXT 10 which is the source key of a                           RELENT.sub.-- KEY/SKIP                                                                              28 rel. (Root is an                                                               edmm.sub.-- data.sub.-- stream)                     10 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    10 Processing the template key                            TMPL.sub.-- KEY/NEXT 10 list of a relent.sub.-- key. The                       RELREL.sub.-- KEY/NEXT                                                                              11 relent.sub.-- key is the source key                    RELENT.sub.-- KEY/NEXT                                                                              12 of a rel. (Root is an                                                          edmm.sub.-- data.sub.-- stream)                     11 FUN.sub.-- CALL/NEXT  2 Processing a relrel.sub.-- key                         TMPL/NEXT             4 which is the target key of a                           REL/NEXT              7 rel. (Root is an                                       OREL/NEXT            36 edmm.sub.-- data.sub.-- stream)                        FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                     12 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    13 Processing a relent.sub.-- key                         TMPL.sub.-- KEY/NEXT 13 which is the target key of a                           RELENT.sub.-- KEY/SKIP                                                                              27 rel. (Root is an                                                               edmm.sub.-- data.sub.-- stream)                     13 FUN.sub.-- CALL/NEXT  2 Processing the template key                            TMPL/NEXT             4 list of a relent.sub.-- key. The                       REL/NEXT              7 relent.sub.-- key is the target key                    OREL/NEXT            36 of a rel. (Root is an                                  TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    13 edmm.sub.-- data.sub.-- stream)                        TMPL.sub.-- KEY/NEXT 13                                                        FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                     14 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    15 Processing a template.                                 TMPL.sub.-- KEY/NEXT 15 (Root is an er.sub.-- data.sub.-- group)               TMPL/SKIP            29                                                     15 TMPL/NEXT            14 Processing the a template                              TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    15 key list of a template. (Root                          TMPL.sub.-- KEY/NEXT 15 is an er.sub.-- data.sub.-- group)                     FIELD/NEXT           16                                                        REL/NEXT             17                                                        OREL/NEXT            37                                                        FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                     16 TMPL/NEXT            14 Processing a field list of a                           FIELD/NEXT           16 template. (Root is an                                  REL/NEXT             17 er.sub.-- data.sub.-- group)                           OREL/NEXT            37                                                        FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                     17 RELREL.sub.-- KEY/NEXT                                                                              18 Processing a rel. (Root is an                          RELENT.sub.-- KEY/NEXT                                                                              19 er.sub.-- data.sub.-- group                            REL/SKIP             29                                                     18 RELREL.sub.-- KEY/NEXT                                                                              21 Processing a relrel.sub.-- key                         RELENT.sub.-- KEY/NEXT                                                                              22 which is the source key of a                                                   rel. (Root is an                                                               er.sub.-- data.sub.-- group)                        19 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    20 Processing a relent.sub.-- key                         TMPL.sub.-- KEY/NEXT 20 which is the source key of a                           RELENT.sub.-- KEY/SKIP                                                                              30 rel. (Root is an                                                               er.sub.-- data.sub.-- group)                        20 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    20 Procesing the template key                             TMPL.sub.-- KEY/NEXT 20 list of a relent.sub.-- key. The                       RELREL.sub.-- KEY/NEXT                                                                              21 relent.sub.-- key is the source key                    RELENT.sub.-- KEY/NEXT                                                                              22 of a rel. (Root is an                                                          er.sub.-- data.sub.-- group)                        21 TMPL/NEXT            14 Processing a relrel.sub.-- key                         REL/NEXT             17 which is the target key of a                           OREL/NEXT            37 rel. (Root is an                                       FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0 er.sub.-- data.sub.-- group)                        22 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    23 Processing a relent.sub.-- key                         TMPL.sub.-- KEY/NEXT 23 which is the target key of a                           RELENT.sub.-- KEY/SKIP                                                                              29 rel. (Root is an                                                               er.sub.-- data.sub.-- group)                        23 TMPL/NEXT            14 Processing the template key                            REL/NEXT             17 list of a relent.sub.-- key. The                       OREL/NEXT            37 relent.sub.-- key is the target key                    TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    23 of a rel. (Root is an                                  TMPL.sub.-- KEY/NEXT 23 er.sub.-- data.sub.-- group)                           FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                     24 TMPL/NEXT            14 Processing an er.sub.-- data.sub.-- group              REL/NEXT             17 that is root unit.                                     OREL/NEXT            37                                                        ER.sub.-- DATA.sub.-- GROUP/SKIP                                                                     0                                                        ER.sub.-- DATA.sub.-- GROUP/GET.sub.-- STREAM                                                        0                                                     25 FUN.sub.-- CALL/NEXT  2 Processing an er.sub.-- data.sub.-- group              FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0 that is a complete stream.                                                     It is paired with a                                                            function.sub.-- call. (Root is an                                              edmm.sub.-- data.sub.-- stream)                     26 ER.sub.-- DATA.sub.-- GROUP/NEXT                                                                     3 Processing a SKIP to the                               FUN.sub.-- CALL/NEXT  2 end of a function call.                                FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0 (Root is an                                                                    edmm.sub.-- data.sub.-- stream)                     27 FUN.sub.-- CALL/NEXT  2 Processing a SKIP to the                               TMPL/NEXT             4 end of a template, or                                  REL/NEXT              7 relation unit. (Root is an                             OREL/NEXT            36 edmm.sub.-- data.sub.-- stream)                        FINAL.sub.--l STATE.sub.-- ID/FINAL.sub.-- STATE                                                     0                                                     28 RELREL.sub.-- KEY/NEXT                                                                              11 Processing a SKIP to the                               RELENT.sub.-- KEY/NEXT                                                                              12 end of a relent source key of                                                  a rel. (Root is an                                                             edmm.sub.-- data.sub.-- stream)                     29 TMPL/NEXT            14 Processing a SKIP to the                               REL/NEXT             17 end of a template, or                                  OREL/NEXT            37 relation unit. (Root is an                             FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0 er.sub.-- data.sub.-- group)                        30 RELREL.sub.-- KEY/NEXT                                                                              21 Processing a SKIP to the                               RELENT.sub.-- KEY/NEXT                                                                              22 end of a relent source key of                                                  a rel. (Root is an                                                             er.sub.-- data.sub.-- group)                        31 FILE.sub.-- DATA.sub.-- GROUP/SKIP                                                                   0 Processing a file.sub.-- data.sub.-- group             FILE.sub.-- DATA.sub.-- GROUP/GET.sub.-- STREAM                                                      0 which is root unit.                                    LINE/NEXT            32                                                     32 LINE/NEXT            32 Processing a line of a                                 FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0 file.sub.-- data.sub.-- group. (Root is a                                      file.sub.-- data.sub.-- group.)                     33 FILE.sub.-- DATA.sub.-- GROUP/SKIP                                                                   2 Processing a                                           FILE.sub.-- DATA.sub.-- GROUP/GET.sub.-- STREAM                                                      2 file.sub.-- data.sub.-- group. It is paired            LINE/NEXT               with a function call. (Root                                                    is an edmm.sub.-- data.sub.-- stream)               34 FUN.sub.-- CALL/NEXT  2 Processing a line of a                                 LINE/NEXT            34 file.sub.-- data.sub.-- group. (Root is an             FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0 edmm.sub.-- data.sub.-- stream)                     35 FUN.sub.-- CALL/NEXT  2 Processing a file.sub.-- data.sub.-- group             FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0 which is a complete strem.                                                     It is paired with a                                                            function call. (Root is an                                                     edmm.sub.-- data.sub.-- stream)                     36 RELREL/NEXT          38 Processing an orel. (Root is                           RELENT/NEXT          39 an edmm.sub.-- data.sub.-- stream)                     OREL/SKIP            27                                                     37 RELREL/NEXT          43 Processing an orel. (Root is                           RELENT/NEXT          44 an er.sub.-- data.sub.-- group)                        OREL/SKIP            29                                                     38 RELENET.sub.-- KEY/NEXT                                                                             41 Processing a relrel.sub.-- key                                                 which is the source key of                                                     an orel. (Root is an                                                           edmm.sub.-- data.sub.-- stream)                     39 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    40 Processing a relent key                                TMPL.sub.-- KEY/NEXT 40 which is the source key of                             RELENT.sub.-- KEY/SKIP                                                                              40 an orel. (Root is an                                                           edmm.sub.-- data.sub.-- stream)                     40 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    40 Processing the template key                            TMPL.sub.-- KEY/NEXT 40 list of a relent.sub.-- key. The                       RELENET.sub.-- KEY/NEXT                                                                             41 relent.sub.-- key is the source key                                            of an orel. (Root is an                                                        edmm.sub.-- data.sub.-- stream)                     41 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    42 Processing a relent.sub.-- key                         TMPL.sub.-- KEY/NEXT 42 which is the target key of an                          RELENT.sub.-- KEY/SKIP                                                                              27 orel. (Root is an                                                              edmm.sub.-- data.sub.-- stream)                     42 FUN.sub.-- CALL/NEXT  2 Processing the template key                            TMPL.sub.-- NEXT      4 list of a relent.sub.-- key. The                       REL/NEXT              7 relent key is the terget key                           OREL/NEXT            36 of an orel. (Root is an                                TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    42 edmm.sub.-- data.sub.-- stream)                        TMPL.sub.-- KEY/NEXT 42                                                        FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                     43 RELENT.sub.-- KEY/NEXT                                                                              46 Processing a relrel.sub.-- key                                                 which is the source key of                                                     an orel. (Root is an                                                           er.sub.-- data.sub.-- group)                        44 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    45 Processing a relent.sub.-- key                         TMPL.sub.-- KEY/NEXT 45 which is the source key of                             RELENT.sub.-- KEY/SKIP                                                                              48 an orel. (Root is an                                                           er.sub.-- data.sub.-- group)                        45 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    45 Processing the template key                            TMPL.sub.-- KEY/NEXT 45 list of a relent.sub.-- key. The                       RELENT.sub.-- KEY/NEXT                                                                              46 relent.sub.-- key is the source key                                            of an orel. (Root is an                                                        er.sub.-- data.sub.`3 group)                        46 TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    47 Processing a relent.sub.-- key                         TMPL.sub.-- KEY/NEXT 47 which is the target key of an                          RELENT.sub.-- KEY/SKIP                                                                              29 orel. (Root is an                                                              er.sub.-- data.sub.-- group)                        47 TMPL/NEXT            14 Processing the template key                            REL/NEXT             17 list of a relent.sub.-- key. The                       OREL/NEXT            317                                                                               relent key is the target key                           TEMP.sub.-- TMPL.sub.-- KEY/NEXT                                                                    47 of an orel. (Root is an                                TMPL.sub.-- KEY/NEXT 47 er.sub.-- data.sub.-- group)                           FINAL.sub.-- STATE.sub.-- ID/FINAL.sub.-- STATE                                                      0                                                     48 RELENT.sub.-- KEY/NEXT                                                                              46 Processing a SKIP to the                                                       end of a relent source key of                                                  an orel. (Root is an                                                           er.sub.-- data.sub.-- group)                        49 RELENT.sub.-- KEY/NEXT                                                                              41 Processing a SKIP to the                                                       end of a relent source key of                                                  an orel. (Root is an                                                           edmm.sub.-- data.sub.-- stream)                     __________________________________________________________________________

PF/CREATING DATA HANDLING FUNCTIONS

To create a data handling function, perform the following steps:

1. From RM select a private tool groups as the current tool group.

2. From the main panel of RM enter of the option to go to the Logical View (LV).

3. Select the option to make a copy of one of the base data handling functions to your own private function.

If you are creating a Load function put EGPLOAD as the source function name and put the name of the function that you wish to create as the target function name. To create an unload function use EGPUNLD, for copy use EGPCOPY and for delete use EGPDELT for the source function name.

4. After the function has been successfully copied return to the main LV panel and enter the name of the function you just added at the top of the panel.

5. Select the option to specify your function's templates. In each template that you add make sure you add an extra field named REL₋₋ NAME that is CHAR 32 (Varying Length).

6. From the main LV panel select the option to create the connections between your templates. (Note: Your template tree can only have one root).

7. From the main LV panel select the option to change the program name from DWKLOGIC to the name of the file in which your function will reside (this can be identical to the name of the function) and change the programming language to C.

8. From the main LV panel select the option to bind the function.

9. From the main LV panel select the option to create the C-Language AIM file (H file) for the function.

10. From the main LV panel select the option to create a report on the new function.

11. Exit RM.

12. Run the EDMM-Productivity Facility program. Specify the Systems CMS, MVS, etc. Specify the THE FUNCTION type UNLOAD, LOAD, DELETE, COPY, or CF.

a. Unload

A function that retrieves a group of connected entities and relationships from the repository and translates the entity, attribute, and relationship information view the Builder function into a CDF data stream.

This function takes any root key as input (i.e. dependent keys and/or user assigned keys).

b. Load

A function that interprets a CDF data stream containing entity, attribute, and relationship information, updating the repository as specified by the action field of each CDF unit.

c. Delete

A function that deletes a group of connected entity and relationship instances from the repository.

d. Copy

A function that copies a group of connected entity and relationship instances in the repository.

e. CF

A function that provides data transfer and remote function routing between the work station and the host platforms.

Enter the function name (Ex. EDXUD00):

Enter the name of the function (this is the target function name used above). Enter the program name (Ex. EDXUD00(°):

Enter the name of the program (this is the name that you specified earlier, it may be identical to the function name).

Enter the Aggregation name (Ex. DBD Definition):

Enter a string that names the object that the function operates on. It does not have to be a defined aggregation name.

UNLOAD generation complete . . .

Source code is in RM120.EDMMSRC0(MYUNLOAD)

LEL is in RM120.EDMMLEL0(MYUNLOAD)

If the function is successfully created a message will indicate where the newly created source code and lel file reside.

13. After the new data handling function has created, compile the function using the C/370 compiler.

14. Link Edit the new function.

FUNCTION INVOCATION EXAMPLES

This section describes the work station steps necessary for invoking the host functions via EDMM. This description is achieved by use of examples and comments describing the behavior. Each example illustrates the use of regular parameters (input and output), a scenario on building the data for EDMM and a scenario on parsing the data returned from the function via EDMM. There are four examples: the first example demonstrates the invocation of a function without any CDF data; the second example has CDF data as input to the host function; the third has CDF data returned back from the host function; and the last example includes the use of CDF data as input and output to the host function.

FUNCTION WITH NO CDF DATA

Following is the work station activity necessary to invoke a function (DELETE) that has no special CDF data. Assume that the DELETE function interface is as follows:

    ______________________________________                                         Function Name: DELETE                                                          ______________________________________                                         (In) SYSKEY        Fixed   31                                                  (In) AGG.sub.-- TYPE                                                                              Char    32                                                  (In) COMMIT        Char    1                                                   (Out) SC           Fixed   16                                                  (Out) CC           Char    8                                                   ______________________________________                                    

1. The Builder is invoked multiple times to build the data stream for EDMM. Note: Only input data needs to be put in the data stream. Output parameters do not need to be built into the data stream.

                                      TABLE 2                                      __________________________________________________________________________     Building CDF Data Stream                                                                            Data-->Name                                                                    Data-->Value                                              Builder              Data-->Temp.sub.-- Key                                    Function                                                                             ID        Action                                                                              Data-->Rel.sub.-- Posn                                                                    Notes                                          __________________________________________________________________________     FIRST EDMM.sub.-- DATA.sub.--                                                                  NONE --         Tells the Builder                                    STREAM.sub.-- ID                                                                              --         to build a CDF                                                      --         data stream for                                                     --         EDMM                                           NEXT  FUN.sub.-- CALL.sub.-- ID                                                                NONE DELETE     Adds function                                                       --         name to the                                                         --         CDF data stream                                                     --                                                        NEXT  FUN.sub.-- PARM.sub.-- ID                                                                NONE SYSKEY     Adds SYSKEY                                                         2022654    input parameter                                                     --         to the CDF data                                                     --         stream                                         NEXT  FUN.sub.-- PARM.sub.-- ID                                                                NONE AGG.sub.-- TYPE                                                                           Adds                                                                DLI.sub.-- DBD.sub.-- DEF                                                                 AGG.sub.-- TYPE                                                     --         input parameter to the                                              --         CDF data stream                                NEXT  FUN.sub.-- PARM.sub.-- ID                                                                NONE COMMIT     Adds COMMIT                                                         Y          input parameter                                                     --         to the CDF data                                                     --         stream                                         WRITE.sub.--                                                                         (ignored) (ignored)                                                                           --         Builder returns address                        MEM                  --         of the EDMM Data Stream.                                            --         (The WRITE.sub.-- FILE builder                                      --         function could also have been                                                  used . . . in this case the data                                               is returned in a file specified                                                by the caller.)                                __________________________________________________________________________      Note:                                                                          This table emphasizes the input parameters that pertain to this scenario.

2. After creating the EDMM Data Stream, the EDMM communication function can be invoked:

    rc=egppt00(cdf.sub.-- filename, &cdf.sub.-- memaddr, cc):

The cdf₋₋ filename would be a null string in this case, since the EDMM Data Stream is in the memory block pointed to by cdf₋₋ memaddr.

3. Upon completion of the DELETE function, egppt00 returns with an output EDMM Data Stream. This information can be read via multiple invocations of the parser.

Note: The caller must release the memory for the CDF data stream returned by EDMM. A function will be provided to perform this action.

Following are the steps necessary to read the data:

                  TABLE 3                                                          ______________________________________                                         Parsing Output CDF Data Stream                                                                         Data-->Name                                                                    Data-->Value                                           Parser                  Data-->Temp.sub.-- Key                                 Function                                                                              ID           Action  Data-->Rel.sub.-- Posn                                                                    Notes                                   ______________________________________                                         FIRST  EDMM.sub.-- DATA.sub.--                                                                     NONE    --                                                        STREAM.sub.-- ID     --                                                                             --                                                                             --                                                 NEXT   FUN.sub.-- CALL.sub.-- ID                                                                   NONE    DELETE                                                                         --                                                                             --                                                                             --                                                 NEXT   FUN.sub.-- PARM.sub.-- ID                                                                   NONE    SC                                                                             0                                                                              --                                                                             --                                                 NEXT   FUN.sub.-- PARM.sub.-- ID                                                                   NONE    CC                                                                             CC.sub.-- OK                                                                   --                                                                             --                                                 ______________________________________                                          Note:                                                                          This table only shows the output parameters that pertain to this scenario                                                                               

FUNCTION WITH CDF DATA AS AN INPUT PARAMETER

Following is the work station activity necessary to invoke a host function that requires CDF data as input. Assume that the function interface is as follows:

    ______________________________________                                         Function Name: MAINTAIN                                                        ______________________________________                                         (In) SYSKEY        Fixed   31                                                  (In) AGG.sub.-- TYPE                                                                              Char    32                                                  (In) CDF.sub.-- MEM                                                                               Fixed   32                                                  (In) CDF.sub.-- FILE                                                                              Char    46                                                  (In) COMMIT        Char    1                                                   (Out) SC           Fixed   16                                                  (Out) CC           Char    8                                                   ______________________________________                                    

1. Following are the steps necessary to build the data stream for EDMM. Note: Only input data needs to be put in the data stream.

                                      TABLE 4                                      __________________________________________________________________________     Building CDF Data Stream for Maintain                                                                 Data-->Name                                                                    Data-->Value                                            Builder                Data-->Temp.sub.-- Key                                  Function                                                                             ID         Action                                                                               Data-->Rel.sub.-- Posn                                                                    Notes                                        __________________________________________________________________________     FIRST EDMM.sub.-- DATA.sub.--                                                                   NONE  --         Tells the Builder                                  STREAM.sub.-- ID --         to build a CDF                                                      --         data stream for                                                     --         EDMM                                         NEXT  FUN.sub.-- CALL.sub.-- ID                                                                 NONE  MAINTAIN   Adds function                                                       --         name to the                                                         --         CDF data stream                                                     --                                                      NEXT  FUN.sub.-- PARM.sub.-- ID                                                                 NONE  SYSKEY     Adds SYSKEY                                                         1123009    input parameter                                                     --         to the CDF data                                                     --         stream                                       NEXT  FUN.sub.-- PARM.sub.-- ID                                                                 NONE  AGG.sub.-- TYPE                                                                           Adds                                                                DLI.sub.-- DBD.sub.-- DEF                                                                 AGG.sub.-- TYPE                                                     --         input parameter to the                                              --         CDF data stream                              NEXT  FUN.sub.-- PARM.sub.-- ID                                                                 NONE  COMMIT     Adds COMMIT                                                         Y          input parameter                                                     --         to the CDF data                                                     --         stream                                       NEXT  ER.sub.-- DATA.sub.-- GROUP                                                               NONE  --         If the ER.sub.-- DATA.sub.-- GROUP                                  --         has already been created, a build                                              function                                                            --         of ADD.sub.-- STREAM should be used to                                         add                                                                 --         the complete ER.sub.-- DATA.sub.--                                             GROUP data                                                                     stream into the current data stream.         NEXT  TEMPL.sub.-- ID                                                                           UPDATE                                                                               DLI.sub.-- DBD                                                                            Adds template id to the                                             --         CDF data stream                                                     --                                                                             --                                                      NEXT  TMPL.sub.-- KEY.sub.-- ID                                                                 NONE  --         Adds template key to                                                1123009    the CDF data stream                                                 --                                                                             --                                                      NEXT  FIELD.sub.-- ID                                                                           UPDATE                                                                               ACCESS     Updtaes template field to the                                       HDAM       CDF data stream (These NEXT                                         --         calls continue for each Template                                    --         unit and Relationship)                       WRITE.sub.--                                                                         (ignored)  (ignored)                                                                            --         Builder returns address of the               MEM                    --         EDMM Data Stream. (The WRITE.sub.--                                            FILE                                                                --         builder function could also have been                               --         used. In this case the data is returned                                        in                                                                             a file specified by the                      __________________________________________________________________________                                       caller.)                                      Note:                                                                          This table emphasizes the input parameters that pertain to this scenario.

It should be noted here that the CDF₋₋ FILE and CDF₋₋ MEM in the Maintain Parameter template actually refer to the host filename and the host memory location of the CDF data. Since it would be unnatural for the work station application to specify these values, the EDMM communication Facility recognizes the CDF data group associated with the function call and sets the host function parameters with the appropriate data.

2. After creating the EDMM Data Stream, the EDMM communication Facility can be invoked:

    rc=egppt00(cdf.sub.-- filename,&cdf.sub.-- memaddr, cc):

The cdf₋₋ filename should be a null string in this case, since the EDMM Data Stream is in the memory block pointed to by cdf₋₋ memaddr.

3. Upon return completion of the MAINTAIn Facility, egppt00 returns with an output EDMM Data Stream. This information can be read via the parser.

Note: The caller must release the memory for the CDF data stream returned by EDMM. A function will be provided to perform this action.

Following are the step necessary to read the data:

                  TABLE 5                                                          ______________________________________                                         Parsing Output CDF Data Stream                                                 ______________________________________                                         Parser ID            Action  Data->Name                                                                               Notes                                   Function                     Data->Value                                                                    Data->                                                                         Temp.sub.-- Key                                                                Data->                                                                         Rel.sub.-- Posn                                   FIRST  EDMM.sub.-- DATA.sub.--                                                                      NONE    --                                                       STREAM.sub.-- ID      --                                                                             --                                                                             --                                                Parser ID            Action  Data->Name                                                                               Notes                                   Function                     Data->Value                                                                    Data->                                                                         Temp.sub.-- Key                                                                Data->                                                                         Rel.sub.-- Posn                                   NEXT   FUN.sub.-- CALL.sub.-- ID                                                                    NONE    MAINTAIN                                                                       --                                                                             --                                                                             --                                                NEXT   FUN.sub.-- PARM.sub.-- ID                                                                    NONE    SC                                                                             0                                                                              --                                                                             --                                                NEXT   FUN.sub.-- PARM.sub.-- ID                                                                    NONE    CC                                                                             CC.sub.-- OK                                                                   --                                                                             --                                                ______________________________________                                          Note: This table only shows the output parameters that pertain to this         scenario.                                                                

FUNCTION WITH CDF DATA AS AN OUTPUT PARAMETER

Following is the work station activity necessary to invoke a host function that has CDF data as Output. Assume that the function interface is as follows:

    ______________________________________                                         Function Name: UNLOAD                                                          ______________________________________                                         (In)SYSKEY              Fixed 31                                               (In)AGG.sub.-- TYPE     Char 32                                                (In)LOCKTYPE            Char 8                                                 (In)HOLDLOCK            Char 1                                                 (Out)CDF.sub.-- MEM     Fixed 32                                               (Out)CDF.sub.-- FILE    Char 46                                                (Out)SC                 Fixed 16                                               (Out)CC                 Char 8                                                 ______________________________________                                    

1. Following are the steps necessary to build the data stream for EDMM.

                                      TABLE 6                                      __________________________________________________________________________     Building CDF Data Stream for Maintain                                          __________________________________________________________________________     Builder                                                                              ID        Action Data->Name                                                                               Notes                                         Function               Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                   FIRST EDMM.sub.-- DATA.sub.--                                                                  NONE   --        Tells the Builder                                   STREAM.sub.-- ID --        to build a CDF                                                       --        data stream for                                                      --        EDMM                                          Builder                                                                              ID        Action Data->Name                                                                               Notes                                         Function               Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                   NEXT  FUN.sub.-- CALL.sub.-- ID                                                                NONE   UNLOAD    Adds function                                                        --        name to the                                                          --        CDF data stream                                                      --                                                      NEXT  FUN.sub.-- PARM.sub.-- ID                                                                NONE   SYSKEY    Adds SYSKEY                                                          6674001   input parameter                                                      --        to the CDF data                                                      --        stream                                        NEXT  FUN.sub.-- PARM.sub.-- ID                                                                NONE   AGG.sub.-- TYPE                                                                          Adds                                                                 DLI.sub.-- DBD.sub.-- DEF                                                                AGG.sub.-- TYPE                                                      --        input parameter                                                      --        to the CDF data                                                                stream                                        Builder                                                                              ID        Action Data->Name                                                                               Notes                                         Function               Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                   NEXT  FUN.sub.-- PARM.sub.-- ID                                                                NONE   LOCKTYPE  Adds                                                                 NOUPDATE  LOCKTYPE                                                             --        input parameter                                                      --        to the CDF data                                                                stream                                        NEXT  FUN.sub.-- PARM.sub.-- ID                                                                NONE   HOLDLOCK  Adds                                                                 N         HOLDLOCK                                                             --        input parameter                                                      --        to the CDF data                                                                stream                                        Builder                                                                              ID        Action Data->Name                                                                               Notes                                         Function               Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                   WRITE.sub.--                                                                         (ignored) (ignored)                                                                             --        Builder returns                               FILE                   --        the data in a file                                                   --        whose name is                                                        --        specified by the                                                               caller. As in the                                                              example before,                                                                the data could                                                                 have been placed                                                               in memory if the                                                               WRITE.sub.-- MEM                                                               function was                                                                   employed.                                     __________________________________________________________________________      Note: This table emphasizes the input parameters that pertain to this          scenario.                                                                

Once again, it should be noted here that the CDF₋₋ FILE and CDF₋₋ MEM parameters in the UNLOAD parameter list refer to the host filename and the host memory of the CDF data. Since it would be unnatural for the work station application to specify these values, the EDMM communication Facility recognizes the CDF data group associated with the function call and sets the host function parameters with the appropriate data.

2. After creating the EDMM Data Stream, the EDMM communication Facility can be invoked:

    rc=egppt00 (cdf.sub.-- filename, &cdf.sub.-- memaddv, cc):

The cdf₋₋ filename contains the name of the file that the user specified to the Builder for the WRITE₋₋ FILE function. The cdf₋₋ memptr should be set to NULL.

3. Upon completion of the MAINTAIn Facility, egppt00 returns with an output EDMM Data Stream. This information can be read via the parser.

Note: The caller must release the memory for the CDF data stream returned by EDMM. A function will be provided to perform this action.

Following are the step necessary to read the data:

                                      TABLE 7                                      __________________________________________________________________________     Parsing Output CDF Data Stream                                                 __________________________________________________________________________     Parser                                                                              ID         Action                                                                               Data->Name                                                                               Notes                                          Function              Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                    FIRST                                                                               EDMM.sub.-- DATA.sub.--                                                                   NONE  --                                                            STREAM.sub.-- ID --                                                                             --                                                                             --                                                       Parser                                                                              ID         Action                                                                               Data->Name                                                                               Notes                                          Function              Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                    NEXT FUN.sub.-- CALL.sub.-- ID                                                                 NONE  UNLOAD                                                                         --                                                                             --                                                                             --                                                       NEXT FUN.sub.-- PARM.sub.-- ID                                                                 NONE  SC                                                                             0                                                                              --                                                                             --                                                       NEXT FUN.sub.-- PARM.sub.-- ID                                                                 CC    CC.sub.-- OK                                                                   --                                                                             --                                                                             --                                                       Parser                                                                              ID         Action                                                                               Data->Name                                                                               Notes                                          Function              Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                    NEXT ER.sub.-- DATA.sub.-- GROUP                                                               NONE  --                                                                             --                                                                             --                                                                             --                                                       NEXT TEMPL.sub.-- ID                                                                           DLI.sub.-- DBD                                                                       --                                                                             --                                                                             --                                                                             --                                                       NEXT TEMPL.sub.-- KEY.sub.-- ID                                                                NONE  DLI.sub.-- DBD                                                                 6674001                                                                        --                                                                             --                                                       Parser                                                                              ID         Action                                                                               Data->Name                                                                               Notes                                          Function              Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                    NEXT FIELD.sub.-- ID                                                                           NONE  NAME                                                                           DBD1                                                                           --                                                                             --                                                       NEXT The rest of the                                                           `. . .`                                                                             Templates and                                                                  Relationships for the                                                          Aggregation Instance.                                                     __________________________________________________________________________      Note: This table only show the output parameters that pertain to this          scenario.                                                                

FUNCTION WITH CDF DATA AS INPUT AND OUTPUT PARAMETERS

Following is the work station activity necessary to invoke a host function that has CDF data as Output. Assume that the function interface is as follows:

    ______________________________________                                         Function Name: SRCMEM                                                          ______________________________________                                         (In)SRCLIB              Char 44                                                (In/Out) CDF.sub.-- MEM Fixed 32                                               (In/Out) CDF.sub.-- FILE                                                                               Char 46                                                (Out)SC                 Fixed 16                                               (Out)CC                 Char 8                                                 ______________________________________                                    

1. Following are the steps necessary to build the data stream for EDMM.

                                      TABLE 8                                      __________________________________________________________________________     Building CDF Data Stream for SRCMEM Function                                   __________________________________________________________________________     Builder                                                                              ID        Action Data->Name                                                                               Notes                                         Function               Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                   FIRST EDMM.sub.-- DATA.sub.--                                                                  NONE   --        Tells the Builder                                   STREAM.sub.-- ID --        to build a CDF                                                       --        data stream for                                                      --        EDMM                                          Builder                                                                              ID        Action Data->Name                                                                               Notes                                         Function               Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                   NEXT  FUN.sub.-- CALL.sub.-- ID                                                                NONE   SRCMEM    Adds function                                                        --        name to the                                                          --        CDF data stream                                                      --                                                      NEXT  FUN.sub.-- PARM.sub.-- ID                                                                NONE   SRCLIB    Adds SRCLIB                                                          LIBI      input parameter                                                      --        to the CDF data                                                      --        stream                                        NEXT  FILE.sub.-- DATA.sub.--                                                                  NONE   --        Adds FILE                                           GROUP.sub.-- ID  --        DATA GROUP                                                           --        to the CDF data                                                      --        stream                                        Builder                                                                              ID        Action Data->Name                                                                               Notes                                         Function               Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                   NEXT  LINE.sub.-- ID                                                                           NONE   --        Adds member                                                          MEMBER1   name as line unit                                                    --        to the CDF data                                                      --        stream                                        NEXT  LINE.sub.-- ID                                                                           NONE   --        Adds member                                                          MEMBER2   name as line unit                                                    --        to the CDF data                                                      --        stream                                        NEXT  LINE.sub.-- ID                                                                           NONE   --        Adds member                                                          MEMBERn   name as line unit                                                    --        to the CDF data                                                      --        stream                                        Builder                                                                              ID        Action Data->Name                                                                               Notes                                         Function               Data->Value                                                                    Data->Temp.sub.-- Key                                                          Data->Rel.sub.-- Posn                                   WRITE.sub.--                                                                         (ignored) (ignored)                                                                             --        Builder returns                               FILE                   --        the data in a file                                                   --        whose name is                                                        --        specified by the                                                               caller. The data                                                               would have been                                                                placed in                                                                      memory if the                                                                  WRITE.sub.-- MEM                                                               function was                                                                   employed.                                     __________________________________________________________________________      Note: This table emphasizes the input parameters that pertain to this          scenario.                                                                

Once again, it should be noted here that CDF₋₋ FILE and CDF₋₋ MEM parameters in the SRCMEM parameter list refer to the host filename and the host memory location of the CDF data. Since it would be unnatural for the Work station application to specify these values, the EDMM communication Facility recognizes the File data group associated with the function call and sets the host function parameters with the appropriate data.

2. After creating the EDMM Data Stream, the EDMM communication Facility can be invoked:

    rc=egppt00 (cdf.sub.-- filename, &cdf.sub.-- memaddr, cc):

The cdf₋₋ filename must contain the name of the file that the user specified to the builder for the WRITE₋₋ FILE function. The cdf₋₋ memptr should be set to NULL.

3. Upon return completion of the SRCMEM function, egppt00 returns with an output EDMM Data Stream. This information can be read via the parser.

Note: The caller must release the memory for the CDF data stream returned by EDMM. A function will be provided to perform this action.

Following are the steps necessary to read the data:

                  TABLE 9                                                          ______________________________________                                         Parsing Output CDF Data Stream                                                 ______________________________________                                         Parser ID            Action  Data->Name                                                                               Notes                                   Function                     Data->Value                                                                    Data->                                                                         Temp.sub.-- Key                                                                Data->                                                                         Rel.sub.-- Posn                                   FIRST  EDMM.sub.-- DATA.sub.--                                                                      NONE    --                                                       STREAM.sub.-- ID      --                                                                             --                                                                             --                                                Parser ID            Action  Data->Name                                                                               Notes                                   Function                     Data->Value                                                                    Data->                                                                         Temp.sub.-- Key                                                                Data->                                                                         Rel.sub.-- Posn                                   NEXT   FUN.sub.-- CALL.sub.-- ID                                                                    NONE    SRCMEM                                                                         --                                                                             --                                                                             --                                                NEXT   FUN.sub.-- PARM.sub.-- ID                                                                    NONE    SC                                                                             0                                                                              --                                                                             --                                                NEXT   FUN.sub.-- PARM.sub.-- ID                                                                    NONE    CC                                                                             CC.sub.-- OK                                                                   --                                                                             --                                                Parser ID            Action  Data->Name                                                                               Notes                                   Function                     Data->Value                                                                    Data->                                                                         Temp.sub.-- Key                                                                Data->                                                                         Rel.sub.-- Posn                                   NEXT   FILE.sub.-- DATA.sub.--                                                                      NONE    --                                                       GROUP                 --                                                                             --                                                                             --                                                NEXT   LINE.sub.-- ID                                                                               NONE    --                                                                             Lib2                                                                           --                                                                             --                                                ______________________________________                                          Note: This table only show the output parameters that pertain to this          scenario.                                                                

Using the foregoing specifications the invention may be implemented using standard programming techniques. The resulting program(s) may be stored on disk, diskettes, memory cards, ROM or any other memory device. For execution, the program may be copied into the RAM of the computer. One skilled in the art of computer science will easily be able to combine the software created as described with appropriate general purpose or special purpose computer hardware to create a system. While the preferred embodiment of the present invention has been illustrated in detail, it should be apparent that modifications and adaptations to that embodiment may occur to one skilled in the art without departing from the scope of the present invention as set forth in the following claims. 

What is claimed is:
 1. A program storage device readable by a machine, tangibly embodying a program of instructions executable by the machine to perform method steps for encoding units of data, the machine having stored units of data, said method steps comprising:(1) reading units of data from storage, each unit of data representing one of entity/relationship data, a function call, and file data; and (2) encoding all of said units of data using a common data format (CDF) according to formal CDF grammar rules to create a data stream comprising said encoded units of data.
 2. The program storage device of claim 1, wherein the machine is linked to a remote computer, said method steps further comprising the step of transmitting the data stream to the remote computer.
 3. The program storage device of claim 1, wherein step (2) comprises the steps of:(a) selecting one of said units of data; (b) generating a prefix for said selected unit of data; and (c) appending said prefix and said selected unit of data to said data stream; and (d) performing steps (a)-(c) for each of said units of data; wherein step (b) comprises the steps of:(i) encoding a length of said prefix and said selected unit of data into a length field of said prefix; (ii) encoding an action associated with said selected unit of data into an action field of said prefix; and (iii) encoding an identifier of said selected unit of data into an identifier field of said prefix.
 4. A program storage device readable by a remote computer, tangibly embodying a program of instructions executable by the remote computer to perform method steps for processing units of data in a data stream generated by a local computer, the units of data in the data stream each representing one of entity/relationship data, a function call, and file data, the local computer having encoded all of the units of data using a common data format (CDF) according to formal CDF grammar rules to create the data stream, said method steps comprising the steps of:(1) parsing the data stream according to said formal CDF grammar rules to extract the units of data from the data stream; (2) detecting a function call in one of said extracted units of data; and (3) passing the function call to a function processor for processing.
 5. The program storage device of claim 4, wherein said method steps further comprise the steps of:(4) collecting one or more units of output data generated by execution of the function call; (5) encoding said one or more units of output data using said common data format (CDF) according to said format CDF grammar rules to create a second data stream comprising said encoded units of output data; and (6) transmitting said second data stream to the local computer system.
 6. A computer program product comprising a computer readable medium having computer program logic recorded thereon for enabling a processor in a computer system to encode units of data, the computer system having stored units of data, said computer program product comprising:means for enabling the processor to read units of data from storage, each unit of data representing one of entity/relationship data, a function call, and file data; and means for enabling the processor to encode all of said units of data using a common data format (CDF) according to formal CDF grammar rules to create a data stream comprising said encoded units of data.
 7. A computer program product comprising a computer readable medium having computer program logic recorded thereon for enabling a processor in a remote computer system to process units of data in a data stream generated by a local computer, the units of data in the data stream each representing one of entity/relationship data, a function call, and file data, the local computer having encoded all of the units of data using a common data format (CDF) according to formal CDF grammar rules to create the data stream, said computer program logic comprising:means for enabling the processor to parse the data stream according to said formal CDF grammar rules to extract the units of data from the data stream; means for enabling the processor to detect a function call in one of said extracted units of data; and means for enabling the processor to pass the function call to a function processor for processing.
 8. The computer program product of claim 7, wherein said computer program logic further comprises:means for enabling the processor to collect one or more units of output data generated by execution of the function call; means for enabling the processor to encode said one or more units of output data using said common data format (CDF) according to said formal CDF grammar rules to create a second data stream comprising said encoded units of output data; and means for enabling the processor to transmit said second data stream to the local computer. 